MurmurSSH

A minimal, local-first SSH, SFTP, and FTP client for Linux.

MurmurSSH is a lightweight desktop application for managing SSH connections and browsing remote files over SFTP or FTP. It is designed for Linux users who want a simple, profile-based tool without cloud accounts, telemetry, or unnecessary complexity.

Built with Tauri and Rust. Free to use, free to modify, free to contribute to.

Website: murmurssh.crispy-web.com

Download: GitHub Releases · SourceForge

Available languages: English, German, French, Dutch, Polish, Russian.

• Multi-protocol support — connect via SSH (terminal + file browser), SFTP (file browser only), or FTP (file browser only). Port is pre-filled automatically for each protocol.
• Profile management — save connection profiles locally with name, host, port, username, and auth settings. No account required.
• Profile groups & sorting — organize profiles into named groups shown as a collapsible accordion (one group open at a time; the last-opened group is remembered across restarts), and sort each group alphabetically or by newest first (the choice is remembered).
• SSH sessions — launch an SSH connection directly in your system terminal with one click.
• Terminal selection — auto-detects a terminal emulator ($TERMINAL, x-terminal-emulator, GNOME Terminal, Ptyxis, GNOME Console, Konsole, Xfce Terminal, kitty, Alacritty, foot, WezTerm, xterm), or pick one explicitly — including a custom command — in Settings. Fixes SSH launch on Arch and other non-Debian distros that lack x-terminal-emulator.
• Parallel connections & launchers — while one connection is active, open a different profile in a second, independent window. Right-click any profile to open it in a new window or create a desktop launcher (a .desktop shortcut for one-click connect from your desktop or app menu). You can also start the app pre-connected from the command line: murmurssh --profile "<name or id>".
• Split-pane file browser — a local file browser panel sits alongside the remote browser, so you can see both sides at once. The panel is toggleable and its position (left or right) is configurable in Settings.
• SFTP/FTP remote browser — browse remote directories, upload files and folders, download files and folders, delete, rename, move, and create files and directories. The listing shows modification dates and permissions, and you can change permissions (chmod) via a right-click dialog with an rwx grid synced to an octal field (SFTP). Works identically over SFTP and FTP.
• Copy to… (remote) — duplicate a remote file or folder to another remote path without a round trip through your machine. Over SSH/SFTP this runs as a server-side cp -a; if the server doesn't support it (or over FTP) MurmurSSH falls back to a download-then-upload through a private temp folder. Cancelling stops the remote command instead of leaving it running.
• Safe uploads — uploads write to a hidden .name.murmur-part file and rename it into place only on success, so a failed or cancelled upload never deletes or truncates the file already on the server. Folder uploads keep going past a per-file error and report how many of the folder's entries failed.
• Local panel multi-select & folder dragging — select multiple files and folders in the local browser (Ctrl/Shift-click, Ctrl+A) and drag a folder — not just files — onto the remote browser to upload it. Dropping onto a folder row in either panel targets that folder directly.
• Drag and drop — drag local files onto the remote browser to upload; drag remote entries onto the local browser to download. Drop files or folders from your OS file manager onto the remote browser to upload.
• Background transfer queue — uploads and downloads run in a background queue, so the app stays responsive even during large or numerous transfers. A transfer panel lists every job (queued, transferring, done, failed, cancelled) with a live progress bar and per-job cancel, plus "Cancel all" and "Clear finished".
• Concurrent transfers — several transfers run at once, each on its own connection (FileZilla-style). The number that run simultaneously is configurable in Settings (1–8, default 2).
• Activity log — a live log panel shows connection events, transfer status, and errors while you work.
• Remote file editing — open a remote text file in your local editor. When you save, MurmurSSH uploads the changes back automatically or asks for confirmation first. Choose a global default editor and per-extension editors in Settings; a profile's editor command still overrides those.
• Update check — optionally check GitHub Releases when the app starts (on by default; toggle in Settings). Use Check now anytime for an immediate check. If a newer version exists, MurmurSSH shows a dialog with a link to the Releases page (no auto-install).
• Directory cache — freshly visited remote directories can be cached in memory for instant navigation when switching back and forth. Configurable globally in Settings and overridable per profile; refresh, upload, delete, rename, move, and new file/folder invalidate the affected directory.
• Duplicate (remote) — right-click a file → Duplicate creates a server-side copy with _copy appended to the name (_copy2, _copy3, … if taken).
• Type-ahead navigation — start typing a name in the remote list and the browser jumps to and selects the first match.
• Connection name in the window title — while connected, the title shows user@host, so the right window is easy to find in Alt/Shift-Tab.
• AI access via MCP (optional, off by default) — let an AI assistant such as Claude Code browse, transfer and run commands on your servers through MurmurSSH, with per-token permissions, allowed profiles, folder limits and a confirmation click in the app for risky actions. See AI access below.
• Multiple auth methods — SSH key, SSH agent, or password authentication.
• Optional password saving — choose whether to save a password locally (machine-only) or inside the profile file (portable), or not at all. SSH key passphrases are never saved.
• Host key verification — unknown host keys are shown with their fingerprint before you accept them. Trusted keys are stored locally.
• Keyboard shortcuts — full keyboard navigation in both file panels (arrows, Shift-select, Home/End, Page Up/Down, type-ahead), plus rename, refresh, new folder, delete, copy/cut/paste, move to…, copy to…, download/upload, and open-terminal shortcuts. Press F1 or ? for the complete, always-up-to-date list in the Help dialog.
• Fully local — all profiles, settings, and credentials stay on your machine. No cloud, no sync, no telemetry.

Screenshots are in docs/screenshots/.

• Ubuntu 22.04 or later, or any compatible Debian-based Linux — Arch and other distributions work too
• A terminal emulator for SSH sessions. MurmurSSH auto-detects one ($TERMINAL, x-terminal-emulator, GNOME Terminal, Ptyxis, GNOME Console, Konsole, Xfce Terminal, kitty, Alacritty, foot, WezTerm, xterm); if none is found, or you prefer a different one, pick it explicitly — including a custom command — in Settings → Terminal.
• xdg-utils (pre-installed on most Ubuntu systems)

sudo apt install \
  libwebkit2gtk-4.1-dev \
  libgtk-3-dev \
  libayatana-appindicator3-dev \
  librsvg2-dev \
  libssh2-1-dev

Releases are published on the GitHub Releases page and mirrored on SourceForge.

Download the latest .deb release from the Releases page and install it:

sudo dpkg -i murmurssh_*.deb

Download the .AppImage from the Releases page. No installation needed — make it executable and run it directly:

chmod +x MurmurSSH_*.AppImage
./MurmurSSH_*.AppImage

The AppImage bundles all dependencies and runs on most Linux distributions without installation.

You need Rust (stable toolchain) and Node.js 18 or later.

# Clone the repository
git clone https://github.com/andrenalin282/MurmurSSH.git
cd MurmurSSH

# Install Node dependencies
npm install

# Start in development mode with hot reload
npm run tauri dev

To build a release package:

# Generate icons from a 1024×1024 PNG (required once before building)
npm run tauri icon path/to/icon.png

# Build .deb and .AppImage
npm run tauri build

Output is written to src-tauri/target/release/bundle/.

Create a profile for each server you connect to:

1. Click New in the sidebar
2. Enter the display name, host, port, and username
3. Select the Protocol:
   • SSH — SSH terminal session + SFTP file browser. Port defaults to 22.
   • SFTP — file browser only (no terminal). Port defaults to 22.
   • FTP — file browser only, for servers that only support FTP. Port defaults to 21.
4. Choose an authentication method (SSH/SFTP only):
   • SSH Key — pick your private key file with the Browse button
   • SSH Agent — delegates to your running ssh-agent
   • Password — entered at connection time; you can choose whether to save it
5. Optionally set:
   • Group — a free-text group name to organize profiles in the sidebar (leave blank for "Ungrouped"). Existing group names are offered as autocomplete.
   • Default Remote Path — the directory opened when you connect
   • Local Path — a local folder used as the default for uploads and downloads
   • Editor Command — the command used to open files for editing (blank = system default)
   • Upload Mode — confirm before upload, or auto-upload on file save
6. Click Save

The last used profile is restored automatically on startup.

Profiles are shown as a collapsible grouped accordion in the sidebar: click a group header to open it (any other open group collapses, so only one is expanded at a time), single-click a profile to select it, and double-click to connect. The last-opened group is remembered across restarts. Use the A–Z / Newest toggle above the list to sort each group alphabetically or by creation date — the choice is remembered across restarts.

Right-click a profile for extra actions:

• Open in new window — launch a second, independent MurmurSSH window connected to that profile.
• Create desktop shortcut — pick a location (defaults to your desktop) and MurmurSSH writes an executable, trusted .desktop launcher that connects to the profile on double-click.

Select a profile and click Connect. MurmurSSH will:

1. Verify the host key / authenticate (SSH/SFTP — prompts for password or passphrase if needed)
2. For SSH profiles: also open an SSH terminal session in your system terminal
3. Load the file browser (all protocols)

While connecting, a cancel button appears in the toolbar so you can abort a slow or unreachable connection.

Parallel connections. While one connection is active, selecting a different profile turns the Connect button into Open in new window, which launches that profile in a separate window — so you can browse several servers at once. Each window is an independent process with its own credentials prompt.

Launch from the command line / a shortcut. Start the app already pointed at a profile with murmurssh --profile "<name or id>" (matched by exact id first, then case-insensitively by name). The Create desktop shortcut action above generates a launcher that does exactly this.

The file browser works the same way over SFTP and FTP.

Uploads are written to a hidden .name.murmur-part file and renamed into place only on success, so a failed or cancelled upload never deletes or truncates a file already on the server; folder uploads keep going past a per-file error and report how many entries failed.

Transfers are queued and run in the background: the transfer panel shows each job's progress and lets you cancel individual jobs or all of them. Several jobs run concurrently (configurable in Settings → Concurrent transfers, 1–8). The activity log below the file list shows what happened and any errors.

See Keyboard shortcuts below for the full list, including navigation (arrows, Shift-select, Home/End, Page Up/Down) that works the same in both panels.

Click the split-pane icon in the toolbar (before the terminal icon) to show or hide the local file browser. When the panel is hidden the icon is highlighted so the state is always visible.

The local browser shows your local filesystem and lets you:

• Navigate by clicking folders, using the Up / Home buttons, or typing a path
• Select multiple files and folders with Ctrl-click / Shift-click, or select everything with Ctrl+A
• Create a new folder, and delete selected files/folders with a confirmation dialog — deletion refuses your / root, your home folder, and any parent folder of your home folder
• Drag one or more files or a whole folder onto the remote browser to upload; dropping onto a folder row (local or remote) targets that folder directly
• Receive drops from remote rows (drag remote → drop on local browser = download)
• Upload the current selection to the remote panel's current folder with Ctrl+U
• Press Tab to switch focus between the local and remote panel — keyboard shortcuts act on whichever panel is active

The last visited path is saved per profile. For shared (portable) profiles each OS user gets their own remembered path.

Open Settings from the sidebar to configure:

MurmurSSH can act as an MCP server, so an AI assistant (e.g. Claude Code) can work on your servers through MurmurSSH — using your profiles, host keys and credentials, without ever seeing passwords. It is off by default and only works while MurmurSSH is running.

Set up

1. Settings → AI access → switch AI access on.
2. New token: pick the allowed profiles (or All profiles, which includes future ones), the permissions, an optional remote folder the AI must stay inside, an optional local folder and an expiry.
3. Copy the shown command (the secret is displayed only once) and register it with your AI client, for example:

   claude mcp add -s user murmurssh -e MURMURSSH_TOKEN=mssh_… -- /usr/bin/murmurssh --mcp

Permissions per token: read, download, upload, write (mkdir/rename), delete, exec, and the separately warned SSH on its own (ssh_direct), which lets the AI start its own host-key-pinned ssh sessions and run commands without a click. Passwords and passphrases are never handed out.

Confirmations: deleting always asks; running commands asks unless ssh_direct is on; uploads, downloads and writes ask when Confirm writes is enabled. A waiting request shows a dialog with a 90-second countdown, restores the window, adds a dock badge and sends a desktop notification. In the dialog you can tick always allow for this profile — per action or everything except delete — for 1 hour, until restart or permanently (delete only for 1 hour or until restart). Standing approvals are listed under the token and can be revoked at any time.

Safety rails: if a remote folder is set, remote paths are jailed to it (symlinks resolved on the server); local paths are limited to the token's local folder, a per-token staging folder and the profile's local folder, never / or your home itself, and never .git, .ssh or .gnupg. Every call is written to ~/.config/murmurssh/ai_audit.jsonl without secrets. Only the first running MurmurSSH window serves AI requests.

Full reference: docs/ai-access.md.

Both file panels support full keyboard navigation and control. Shortcuts act only on the currently active panel (click it, or use Tab to switch) and are ignored while typing in a text field. Press F1 or ? at any time to open the in-app Help dialog — it always lists the complete, current set of shortcuts and is the authoritative reference if this table ever falls behind.

General

Both panels

In the path input field specifically: Enter navigates to the typed path, Esc resets it.

Remote panel

Local panel

Dialogs

Letter-key shortcuts also work on non-Latin keyboard layouts (e.g. Russian).

When connecting with password authentication, you choose how to handle the password:

SSH key passphrases are never saved. They are prompted at connection time and discarded immediately after.

To clear a saved password: open the profile in Edit → Clear Saved Credential.

If your SSH private key is stored on a mounted or network filesystem, the system ssh client may reject it with "UNPROTECTED PRIVATE KEY FILE" because the filesystem does not honour UNIX file permissions as expected by OpenSSH.

When this happens, MurmurSSH will prompt you to create a local runtime copy of the key:

• The copy is stored in ~/.config/murmurssh/runtime-keys/ with 0600 permissions
• The terminal session uses the copy instead of the original
• The original key file is never modified
• The copy is temporary — it is deleted when you disconnect or when the app starts up

No passphrase is stored. If the key requires a passphrase, the terminal will still prompt you interactively.

All data is stored locally in ~/.config/murmurssh/:

~/.config/murmurssh/
  profiles/        # One JSON file per saved profile
  settings.json    # App settings (last used profile, etc.)
  secrets/         # Machine-local saved passwords (0600, never synced)
  workspace/       # Local cache of files opened for editing (not cleaned automatically)
    .copy-tmp/     # Private per-process temp folder for Copy to… fallback (download+upload); cleaned on exit and at startup
  known_hosts      # Accepted SSH host key fingerprints
  runtime-keys/    # Temporary key copies for terminal compatibility (0600, deleted on disconnect)
  run/             # SSH control sockets
  logs/            # Application logs

Profiles are plain JSON and can be edited manually or copied between machines.

src/                    # Vanilla TypeScript frontend (no framework)
  api/index.ts          # Typed wrappers for all Tauri IPC commands
  components/           # DOM-based UI components
  types.ts              # Shared TypeScript types
  main.ts               # App entry point
src-tauri/src/
  models/               # Rust data types (Profile, Settings, FileEntry)
  services/             # Business logic (SSH, SFTP, FTP, profiles, secrets, workspace)
  commands/             # Tauri IPC handlers
  lib.rs                # Command registration

MurmurSSH is free and open source. Contributions are very welcome.

Whether it's a bug report, a small fix, a usability improvement, or documentation — all contributions are appreciated.

Before opening a pull request:

• Read PRD.md — it defines what this project is and is not
• Keep changes focused and minimal
• Prefer simple solutions over clever ones
• Stay within the existing architecture

Good first areas to contribute:

• Bug reports and reproducible test cases
• UI polish and accessibility improvements
• Documentation improvements
• Platform testing on Debian, Fedora, or other distributions

Please open an issue first for larger changes so we can discuss the approach before you invest time in it.

MurmurSSH is released under the MIT License.

• Deletion is permanent — there is no undo or trash recovery
• Binary files and files larger than 1 MB cannot be opened for editing
• Each SFTP/FTP operation opens a fresh connection — not optimised for rapid sequential use
• FTP byte-level progress is not available (suppaftp does not support mid-transfer callbacks); progress updates per file instead
• Overwriting a remote file via upload breaks existing hard links to it, and the file's owner may change if you are not its owner
• FTP uploads cannot preserve file permissions
• Copy to… falls back to a slower download-then-upload through your machine on SFTP-only servers (no shell access) and always on FTP
• A custom terminal command is split on spaces — it cannot contain quoted arguments
• The workspace edit cache (~/.config/murmurssh/workspace/) is not cleaned automatically
• No Windows or macOS support — Linux only, by design
• Please report bugs via the issue tracker