A cross-platform terminal workspace with local shells, SSH, Telnet, and a dual-pane local and SFTP file manager.
CorePTY is a tabbed desktop terminal workspace built with Tauri 2, xterm.js, and Rust. It provides local pseudo-terminal sessions, SSH connections, Telnet connections, and a Commander-style file manager for this machine and SFTP servers in one interface, without bundling a Chromium runtime.
Connection profiles can be organized into nested folders. Saved passwords and private-key passphrases are stored in the operating system keychain rather than in the profile file.
- Local shells backed by native PTYs: ConPTY on Windows and
openptyon macOS and Linux. - SSH password authentication and Ed25519 or ECDSA private-key authentication
through
russh. - SSH host-key verification using
~/.ssh/known_hosts, with trust on first use. - Telnet option negotiation for ECHO, SGA, terminal type, and window size.
- Windows administrator sessions through a UAC broker and restricted named pipes.
- Saved connections, nested folders, drag-and-drop organization, and custom connection colors.
- Dynamic terminal titles, tab duplication, reconnect support, search, and configurable right-click behavior.
- A Commander-style file manager (in the spirit of Norton Commander and WinSCP): two panels, each showing this machine or an SFTP server, so files move local to remote, remote to local, or between two servers.
- SFTP on the SSH connection a terminal tab already has (no second login), or on a saved connection; remote panels can follow the terminal's working folder.
- A background transfer queue with progress, speed, and time left; clashes ask
once per item (overwrite, skip, keep both, newer only, or apply to all), big
files resume from a
.filepartafter an interruption, and jobs pause while a connection is down and carry on after Reconnect. - Remote files: view in place, open a downloaded copy, or edit one in your editor with every save uploaded back (after checking the server's file didn't change meanwhile); a Properties dialog with a permissions (chmod) editor.
- Keyboard-first marking (Insert, Space, Shift+movement, numpad masks), quick search by typing, filters, history, sortable columns, drag and drop, and a clipboard; Trash/Recycle Bin for local files and explicit permanent delete.
- Restore your tabs: CorePTY keeps a snapshot of the open tabs and offers to
reopen them at startup (or from the
+menu), each local shell in its folder, and a tab that was running Claude Code resumes the same session with the same options (--dangerously-skip-permissions,--model, …). - Eight built-in application and terminal themes.
- Configurable fonts, cursor styles, scrollback, bell behavior, minimum contrast, and copy-on-select.
The file manager keeps the speed and two-panel structure of classic Commander
tools while using CorePTY's current theme and modern desktop conventions. Each
panel shows a location on a filesystem: this machine, or an SFTP server opened
from the location menu (Alt+F1 / Alt+F2), from an SSH tab's context menu
("Open SFTP"), or from a saved connection. Panels on one server share a single
SFTP session, so a move between them is a rename on the server. Remote names
are kept byte for byte; names Windows can't store (a:b, CON) are saved
under safe spellings when downloaded.
With Restore tabs on (Settings, on by default), CorePTY looks at its tabs
every 30 seconds, shortly after a change (a tab opened, closed, moved or
renamed, a folder changed), and as the window closes, and keeps what it sees in
tabs.json in its configuration folder. At the next start it lists those tabs,
with what each will run, and reopens the ones you keep ticked, in their order:
- Local shells reopen in their folder: Command Prompt's and bash's folder is
read from the shell process; PowerShell is set to report its folder at each
prompt (OSC 7), since its process doesn't follow
cd. - A tab running Claude Code (found through the session file Claude keeps for
each running session) reopens in Claude's folder and types
claude --resume <session> <options>once the shell is ready. Options that say how Claude runs are kept; ones that pick a session or make it a one-shot run (--continue,--print, an opening prompt, …) are left out, as are values that can't be typed safely in that shell; the dialog shows both. A session already open elsewhere isn't resumed a second time, and one that never had a message starts afresh with the same options. - SSH and Telnet tabs of saved connections reconnect (asking for a password only if the keychain has none); file manager tabs reopen their local folders. Administrator tabs and unsaved SSH logins aren't reopened.
Prebuilt packages are available from the latest GitHub release.
| Platform | Package | Notes |
|---|---|---|
| Windows 10/11 x64 | CorePTY_<version>_x64-setup.exe |
NSIS installer; upgrades an existing per-user installation in place. |
| Windows x64 portable | CorePTY_<version>_x64-portable.exe |
Standalone executable; requires the Microsoft Edge WebView2 runtime. |
| macOS universal | CorePTY_<version>_universal.dmg |
Supports Intel and Apple Silicon. |
| Linux x86-64 | CorePTY_<version>_amd64.AppImage |
Portable AppImage. Mark it executable before launching. |
| Debian or Ubuntu x86-64 | CorePTY_<version>_amd64.deb |
Install with sudo apt install ./CorePTY_<version>_amd64.deb. |
Release artifacts are currently unsigned. Operating systems may therefore show a security prompt on first launch.
- Saved SSH passwords and key passphrases are held by Windows Credential
Manager, macOS Keychain, or Linux Secret Service. They are not written to
sessions.toml. - A previously unknown SSH host key is accepted only if CorePTY can record it
in
~/.ssh/known_hosts. A changed key is rejected. Users should independently verify a new host's fingerprint when first connecting. - RSA private keys and RSA-only servers are currently unsupported because the available Rust RSA implementation has an unresolved network-observable timing side channel. Use Ed25519 or ECDSA keys and host-key algorithms.
- Windows administrator tabs use an elevated broker connected through named pipes restricted to Administrators and SYSTEM. The main CorePTY process can send input to that elevated shell by design.
- Local file-manager commands run with the normal CorePTY process permissions. Native paths remain in the Rust backend as opaque tokens instead of being assembled in the webview, and file-manager tabs do not inherit terminal elevation.
- SFTP uses the same SSH host-key checks as terminal tabs. Opening SFTP on an SSH tab reuses that tab's authenticated connection; a saved connection logs in with its keychain secret or asks for the password.
- Remote files that are opened or edited are downloaded into a per-file folder
under the system temp directory (on Linux, one only you can enter), marked as
downloaded on Windows (so SmartScreen and Office's Protected View apply), and
deleted when their tab closes, unless they hold changes the server doesn't
have (a save that couldn't be uploaded, or edits to a copy opened with
Enter, which is never uploaded): then the copy is kept and you are told where. Opening a remote file asks first unless its type is one known to be safe to open (text, data, documents without macros, pictures, sound, video, archives), and always when its name holds text-reversing characters: anything else (a program, a script, a shortcut, a type an interpreter handles) could run on this computer.F4opens files in an editor and never runs them. - Saving an edited file uploads it only after checking that the server's copy didn't change meanwhile (an upload of yours that was cut off isn't taken for someone else's change). It keeps the file's permissions (set before any of its contents are written) and owner, writes through links to the file they point at, and doesn't replace a folder. Hard links and extended attributes are kept only when the file is written in place (when its owner would change, its folder takes no new files, or the server won't set permissions).
- The tabs snapshot (
tabs.json) holds tab names, folders, saved-connection ids, and the id, folder and options of the Claude Code sessions in them; never a password or passphrase. To see what runs in a tab, CorePTY reads the processes under its own shells and Claude Code's session files (not its key files). A restore types only what its dialog showed, and only after you choose Restore; a session running with--dangerously-skip-permissionsresumes with it. - Telnet provides no transport encryption or server authentication. Use it only with systems and networks where cleartext access is acceptable.
On macOS, use Command in place of Control for shortcuts that use Ctrl.
| Shortcut | Action |
|---|---|
Ctrl+Shift+T |
Open the default local shell |
Ctrl+Shift+N |
Open the connection dialog |
Ctrl+Shift+E |
Open a local file-manager tab |
Ctrl+Shift+W |
Close the active tab |
Ctrl+Shift+R |
Reconnect the active terminal session |
Ctrl+Shift+K |
Reset the terminal (clear stuck mouse/paste modes) |
Ctrl+Shift+F |
Search the active terminal buffer |
Ctrl+Shift+C |
Copy the current selection |
Ctrl+Shift+V |
Paste through the terminal input handler |
Ctrl+, |
Open settings |
Ctrl+Tab |
Select the next tab |
Ctrl+PageUp / Ctrl+PageDown |
Select the previous or next tab |
Double-tap Shift |
Open the tab switcher |
| Double-click a tab | Set a custom tab title |
Within a file-manager panel:
| Shortcut | Action |
|---|---|
Tab |
Switch active panel |
Ctrl+U |
Swap the two panels |
Arrow keys, Page Up / Page Down, Home / End |
Move the cursor (marks stay as they are) |
Shift + those keys |
Mark a range |
Insert / Space |
Mark or unmark (Insert also moves down) |
Ctrl+A |
Mark everything |
Numpad + / - / * |
Mark or unmark files by a mask, invert the marks |
| Typing a name | Jump to it (quick search) |
Esc |
End a quick search, close the filter, or clear the marks |
Enter / double-click |
Open a folder, or open a file (a remote one as a downloaded copy; programs and scripts ask first) |
Backspace / Alt+Up |
Open the parent folder |
Ctrl+\ |
Go to the root folder |
Alt+Left / Alt+Right |
Navigate folder history |
Alt+F1 / Alt+F2 |
Choose a location for the left / right panel: this machine, the panel's server, SSH tabs, saved connections |
Alt+Enter |
Properties (size, dates, owner, permissions) |
Ctrl+F |
Filter the current folder |
Ctrl+R |
Refresh |
Ctrl+C / Ctrl+X / Ctrl+V |
Copy, cut, or paste files |
F2 / Shift+F6 |
Rename |
F3 |
View a text file or image |
F4 |
Edit: a local file opens with its app; a remote one in your editor (Settings › File manager; blank: on Windows the type's editor for documents and pictures, else Notepad; elsewhere the desktop's text editor), uploaded on every save |
F5 / F6 |
Copy or move to the other panel |
F7 |
Create a folder |
F8 / Delete |
Move to Trash or Recycle Bin (delete, after confirmation, on servers) |
Shift+F8 / Shift+Delete |
Delete permanently after confirmation |
Operations act on the marked items, or on the one under the cursor when nothing
is marked. Dragging between panels copies by default; hold Shift while
dropping to move. Ctrl/Command-click and Shift-click mark with the mouse.
CorePTY includes CorePTY Dark, CorePTY Light, Dracula, Nord, Solarized Dark, BBS, Synapse, and Starbase. A theme changes both the application interface and the terminal palette.
![]() CorePTY Dark |
![]() CorePTY Light |
![]() Dracula |
![]() Nord |
![]() Solarized Dark |
![]() BBS |
![]() Synapse |
![]() Starbase |
| Area | Implementation |
|---|---|
| Desktop shell | Tauri 2 and each platform's native webview |
| Terminal renderer | xterm.js 6 with fit, search, Unicode, web-links, and WebGL addons |
| Local sessions | portable-pty |
| SSH | russh with the ring cryptography backend |
| Telnet | CorePTY's bounded IAC parser over Tokio TCP |
| Credentials | keyring with native platform backends |
| File manager | A provider-neutral filesystem layer (this machine and SFTP) with byte-exact paths, a background transfer queue (staged writes, resumable .filepart copies, pause on connection loss), and OS Trash/Recycle Bin integration |
| SFTP | CorePTY's SFTP v3 client on russh channels: requests pipelined for throughput, connections shared with terminal tabs, file data on its own channel |
| Profiles and settings | Atomically replaced TOML and JSON files in the application config directory |
| Tab context | sysinfo for the processes under each local shell (folder, command line) and Claude Code session files, for restoring tabs |
The frontend and native session drivers communicate through Tauri commands and binary-safe events. Terminal sessions and file managers implement a shared tab lifecycle while keeping PTY and filesystem capabilities separated.
All platforms require:
- Node.js 20 or later.
- Rust stable.
- The platform prerequisites listed in the Tauri documentation.
Additional platform requirements:
-
Windows: the MSVC Rust toolchain, Visual Studio 2022 Build Tools with the Desktop development with C++ workload, a Windows SDK, and WebView2.
-
macOS: Xcode Command Line Tools.
-
Debian or Ubuntu:
sudo apt-get update sudo apt-get install -y \ build-essential file libayatana-appindicator3-dev libdbus-1-dev \ libgtk-3-dev librsvg2-dev libssl-dev libwebkit2gtk-4.1-dev \ patchelf pkg-config wget
Install the locked frontend dependencies and start Tauri in development mode:
npm ci
npm run tauri devRun the same frontend and native checks used by continuous integration:
npm run check
cd src-tauri
cargo fmt --all -- --check
cargo clippy --all-targets -- -D warnings
cargo test --all-targetsnpm run check performs TypeScript type checking, runs the Vitest suite, and
produces a release-mode frontend bundle.
The SFTP tests talk to a real OpenSSH sftp-server over its standard streams:
Git for Windows ships one, and Linux and macOS have OpenSSH (set
COREPTY_SFTP_SERVER to use another binary). Tests against a full sshd are
marked #[ignore]; scripts/sftp-real-tests.sh starts a throwaway one on
127.0.0.1 and runs them (--bench adds a throughput benchmark).
Regenerate the README's deterministic screenshots (the theme gallery and the
file manager, local and with SFTP) on Windows with
npm run screenshots.
From the repository root:
npm run tauri buildTauri writes native binaries and installers under src-tauri/target/release.
The exact bundle directory depends on the operating system and selected target.
The versions in package.json, src-tauri/Cargo.toml, and
src-tauri/tauri.conf.json must match, and CHANGELOG.md lists
what each release changes. Push a corresponding version tag to run the
cross-platform release workflow:
git tag v<version>
git push origin v<version>The workflow validates the versions, runs the automated checks, builds each platform package, and publishes one GitHub release containing the resulting artifacts.
CorePTY is licensed under the GNU General Public License v3.0 or later.









