A graphical terminal multiplexer for Linux, macOS and Windows.
Splitty brings terminals from your own machine and multiple SSH hosts into one window. Organize them in splits, tabs and named screens. Remote sessions keep running when you close the app or lose the connection, so you can reconnect and continue where you left off.
Working with coding agents helped shape Splitty: keeping track of many Claude Code or Codex sessions running in parallel, sometimes across several projects, with dev servers and tests alongside them, locally or on remote VMs.
Status: a personal project in active development (0.x), used daily on all three systems. Expect rough edges and changes between versions.
- Features
- Install
- Getting started
- Advanced: the
splittycommand - How it works
- Keyboard shortcuts
- Configuration
- Security
- Limitations
- Documentation
- Building from source
Arrange terminals in splits and tabs with drag and drop or shortcuts, and keep separate layouts on named screens. The drawer lists every screen, local and remote, with what runs in it.
- Remote screens. Pick a host from your
~/.ssh/configor type one in, and its screens open next to your local ones. Splitty installs itself on the host over SSH, so Linux and macOS hosts need no setup. - Reconnect where you left off. Your remote sessions keep running when you close your laptop or switch networks. Reconnect and carry on.
- Ports. Splitty notices when a program in a remote terminal listens on a
port, such as a dev server. Forward it with a click;
localhostlinks in remote terminals then open through the forward. - Plain SSH. Splitty connects with your
sshand its configuration, and needs no exposed Splitty port on the host.
More in Remote development.
- Drop files onto a terminal to copy them to its machine, local or remote, and insert their paths.
- Paste a screenshot with Ctrl+V (Cmd+V on macOS). It is stored on the terminal's machine, so Claude Code on a remote host can read it.
- Download a file from a terminal with
splitty download <file>; the window offers to save it. - Open a terminal's folder in VS Code or Zed on your computer from its context menu, remote folders included.
More in Files and editors.
- Let your coding agent use Splitty. It can start dev servers, run tests or launch other agents in tabs and splits alongside your own terminals. You can follow along and interact with them directly.
- Scratchpad. Each terminal has one (Cmd/Alt+J) for drafting the next prompt while the agent works. It stays with the session, and the agent can't read it.
- Viewer panes.
splitty open PLAN.mdshows a file next to the terminal, Markdown and HTML rendered, and follows its changes, so an agent can show you its plan or report. A terminal selection opens the same way from the context menu. Comment on passages or suggest changes, send the review to the agent's terminal as Markdown, and follow the agent's replies in each thread;splitty reviewlets an agent wait for your verdict, and as a hook of Claude Code it opens each plan for approval (setup).
To get started, add this to your CLAUDE.md or AGENTS.md:
Use Splitty to run commands and launch other agents in tabs and splits; first read
splitty agent guide.
More in Managed terminal jobs.
Download the package for your system from the
latest release, or with
the GitHub CLI, for example
gh release download --repo npgrosser/splitty --pattern 'Splitty_*_aarch64.dmg'.
| System | File | Notes |
|---|---|---|
| Windows 10/11 (x64) | Splitty_<version>_x64-setup.exe |
Local terminals run in WSL 2 (Ubuntu or Debian): the app uses the default distribution and installs its backend there. To update, run the newer installer; it replaces an installed earlier version. |
| macOS | Splitty_<version>_aarch64.dmg (Apple silicon) or Splitty_<version>_x64.dmg (Intel) |
Clear the quarantine flag after installing (below). |
| Linux (x86_64) | splitty_<version>_amd64.deb, splitty-<version>-1.x86_64.rpm or splitty-<version>-linux-x86_64.tar.gz |
Install the deb (Debian, Ubuntu) or rpm (Fedora, openSUSE) with the system's package manager and start Splitty from the application menu or as splitty-gpui. The tar.gz runs from where it is unpacked: ./splitty-gpui. |
The app draws its own interface on the GPU (Vulkan on Linux, Wayland or X11)
and needs no browser engine. The deb and rpm install to /opt/splitty and name
the libraries they need; with the tar.gz, keep the splitty command and the
shell-integration/ folder next to splitty-gpui.
On macOS, clear the quarantine flag after installing:
xattr -dr com.apple.quarantine /Applications/Splitty.appLocal and remote terminals have the
splitty command for the agent features and
splitty download.
- Start the app. It opens one screen with one terminal and the drawer pinned beside it. Use the pin button to hide the drawer when not in use; your choice is remembered.
- Split with Cmd/Alt+D and Cmd/Alt+Shift+D, open a tab with Cmd/Alt+T and a screen with Ctrl+Shift+Space. Ctrl+B opens the drawer when it is unpinned.
- For a remote screen, open Hosts at the bottom of the drawer (or
Connect to Host… in the command palette), pick a host and choose
New Screen. Connect to a new host once with plain
sshfirst to accept its key. - Cmd/Alt+Shift+P opens the command palette with everything else, and Ctrl+, the settings.
Cmd is for macOS, Alt for Linux and Windows; all shortcuts are listed below.
Templates (Cmd+P on macOS, Alt+P elsewhere) opens the saved-template library. Save the current Screen by reviewing its extracted layout and choosing which commands to retain. Loading a template lets you create a new Screen or replace the current one. Replacement ends that Screen's existing terminals, including with Layout only; use Run displayed commands only after reviewing the exact command list.
Day to day, everything happens in the UI. The splitty command adds a few
things on top:
| Command | What it does |
|---|---|
splitty attach |
Shows a session in a plain terminal, without the UI |
splitty daemon start |
Starts an independent persistent local backend (macOS, Linux) |
splitty open <path> |
From inside a pane: shows a file in a viewer pane next to it; folders and --editor go to your editor |
splitty run, splitty logs |
Managed background processes, mostly for agents |
Everything about the command is in docs/cli.md.
Terminals of the app and on remote hosts have it already. The app doesn't put
it on the PATH of other terminals; take it from the archive of the same
release:
# Linux x86_64; on other systems splitty-wsl-aarch64 or splitty-darwin-<arch>
mkdir -p ~/.local/share/splitty-cli
tar -xzf splitty-wsl-x86_64.tar.gz -C ~/.local/share/splitty-cli
export PATH="$HOME/.local/share/splitty-cli:$PATH" # add this to your shell profileKeep the shell-integration/ folder next to the binary. On a Mac, if the
browser downloaded the archive, run
xattr -dr com.apple.quarantine ~/.local/share/splitty-cli.
| Connection | Transport | Session lifetime |
|---|---|---|
| Desktop, local terminals | In-process service on macOS and Linux, owned child pipes to the WSL backend on Windows | End when the app quits |
| Explicit local daemon | Private Unix socket | Independent of the app |
| SSH host | SSH data channel to the host’s private socket | Survive disconnects and app exit |
| Explicit browser access | Loopback HTTP/WebSocket gateway to one selected backend | Follow that backend’s lifetime |
- The server holds the layout and the terminals, so several windows can show the same screens and stay in sync.
- The desktop app owns its local backend and closes its local sessions when you quit. A separately started daemon runs independently. On an SSH host, Splitty runs as a daemon and keeps each session in a small keeper process, so sessions survive disconnects and daemon restarts or updates.
- For remote screens, the local server is a hub: it installs and starts Splitty on the host and relays it over SSH.
- The server and the desktop app are Rust. The server uses Tokio, Axum and portable-pty; the desktop app is built with GPUI and parses terminal output with libghostty-vt, Ghostty's terminal library. On Windows the server runs in WSL 2.
More in docs/architecture.md.
| Action | macOS | Linux, Windows |
|---|---|---|
| Split right / down | Cmd+D / Cmd+Shift+D | Alt+D / Alt+Shift+D |
| New tab | Cmd+T | Alt+T |
| Close tab | Cmd+W | Alt+W |
| New screen | Ctrl+Shift+Space | Ctrl+Shift+Space |
| Switch to screen 1–9 | Cmd+Shift+1–9 | Alt+Shift+1–9 |
| Next / previous pane | Cmd+Shift+→ / ← | Alt+Shift+→ / ← |
| Focus up / down | Cmd+Shift+↑ / ↓ | Alt+Shift+↑ / ↓ |
| Resize pane | Ctrl+Shift+Arrow | Ctrl+Shift+Arrow |
| Maximize pane | Cmd+M | Alt+M |
| Scratchpad | Cmd+J | Alt+J |
| Open URL or port in the browser | Cmd+O | Alt+O |
| Templates | Cmd+P | Alt+P |
| Command palette | Cmd+Shift+P | Alt+Shift+P |
| Drawer | Ctrl+B | Ctrl+B |
| Settings | Ctrl+, | Ctrl+, |
| Zoom in / out / reset | Cmd+= / Cmd+- / Cmd+0 | Ctrl+= / Ctrl+- / Ctrl+0 |
The settings (Ctrl+,) are saved in config.toml in ~/.config/splitty/
(macOS: ~/Library/Application Support/splitty/). Custom themes go into a
themes/ folder next to it: UI themes as GPUI Kit theme sets (*.json) and
terminal palettes as Ghostty theme files. Themes describes
both and what ships with the app.
Whoever controls Splitty gets a shell with your rights, so it is built to be
reachable only by you. Desktop connections use IPC or pipes; daemons use
private Unix sockets, and remote connections travel over SSH. Only explicit
browser access starts a loopback HTTP/WebSocket gateway, with single-use
sign-in codes, HttpOnly cookies and origin checks. Shells in panes never
receive a browser credential. Processes running as your own user are not isolated from
Splitty, as with tmux.
The full model is in SECURITY.md. Please report
vulnerabilities privately through
GitHub security advisories.
- The binaries are not code-signed (see Install).
- On Windows, local terminals need WSL 2. Without a supported distribution the app says so and does not start.
- On a Mac host, Splitty doesn't detect listening ports yet; forward them by number.
| Document | Content |
|---|---|
| Remote development | Remote screens, ports, host requirements, installing Splitty on hosts |
| Files and editors | Drop uploads, screenshots, splitty download, splitty open, VS Code, Zed and SFTP |
The splitty command |
Server modes, daemon, attach, in-pane commands |
| Managed terminal jobs | splitty run, logs, agent grants |
SECURITY.md |
Threat model and guarantees |
| Known issues | Upstream bugs and platform quirks, with workarounds |
| Architecture | How the server, protocol and UI fit together |
| Connections and networking | Visual guides to IPC, SSH, listeners and session lifetime |
| Development | Building, packaging and releasing |
| Desktop app | State, packages and open work of the desktop app |
| Roadmap | Milestones and what comes next (German) |
You need Rust (stable), Node.js 24 with pnpm (the splitty command embeds the
assets built in frontend/; the desktop app alone does not), Python 3 and a C toolchain for the terminal library and,
on Linux, the development packages listed in
Development.
make native-package # deb, rpm and tar.gz (Linux) or dmg (macOS) in build/
make install-no-gui # only splitty, to ~/.local/binRunning the app from a checkout, the Windows installer and releases are
described in Development. A
build of your own installs itself on remote hosts only with a payload: set
SPLITTY_REMOTE_PAYLOAD as
Remote development explains, or
put splitty on the host's PATH.
Bugs, rough edges and ideas are welcome as GitHub issues.
MIT, see LICENSE.

