TermZip

A fast, beautiful terminal for people who build things.
An open-source desktop terminal written in Rust that turns every command into a block you can copy and re-run.

Website · Getting started · Roadmap · Architecture · Tabs and panes · Themes · Keyboard · Plugins · Snippets · SSH and WSL · Configuration · Shell integration · Troubleshooting · Compatibility · Test matrix · Distribution · Stability · Contributing

TermZip is a native desktop terminal for macOS, Windows, and Linux. You type straight into a real terminal, and a side rail turns every finished command into a block with its exit code, duration, and output — ready to copy or run again. Tabs and split panes keep several shells in one window, and your layout comes back on the next launch.

Highlights

• Type where you read. The terminal is the only input: your shell's line editor, history, completion, and keybindings work exactly as they do in any terminal.
• Real command blocks. With an integrated shell, every command becomes a card with its command text, exit code, duration, working directory, and an ANSI-colored output preview — copyable and re-runnable in one click.
• Tabs and split panes. Several shells in one window, split right or down, resizable, each with its own blocks. Your tabs, splits, and folders are restored on the next launch (structure only, never terminal output).
• Find and filter. ⌘F searches the scrollback with highlights and a count; the blocks rail filters by text and by status.
• Links that are safe to click. ⌘+click opens URLs, hyperlinks, and files; a click can never start a program.
• Profiles. A shell, folder, and environment per profile, one click away from the new-tab button.
• A real terminal, always. The canvas is a full terminal emulator: vim, htop, tmux, SSH, and REPLs work as usual, with selection, clipboard, bracketed paste, and resize.
• Private by design. No accounts, no telemetry, no cloud. Terminal contents never leave your machine.
• Rust core, native shell. Sessions run in a real PTY via a small Rust engine; the interface is a fast Tauri app.
• Themes you can bring. Twelve audited themes (Catppuccin, Dracula, Nord, Gruvbox, Tokyo Night, One Dark, Rosé Pine and TermZip's own) recolor the whole window, and iTerm2, Windows Terminal, Ghostty, Kitty and Alacritty themes import as they are.
• Yours to shape. Cursor, line height, letter spacing, a translucent window with native blur, and a look of its own for each profile.
• Every shortcut is yours. Rebind any of them in Preferences, with a warning before you take a key your shell uses, and find anything with the command palette (⇧⌘P).
• Plugins in a sandbox. Small WebAssembly files add palette commands, block labels, status items and links. A plugin cannot read your files, use the network or start a program; it asks for each thing it may see or do, and you approve it first. A signed catalog is one click away, and you can write your own in Rust.
• Snippets that never run on their own. Keep the commands you type again, with {{values}} to fill in (git checkout {{branch:main}}). ⇧⌘S lists them, a small form asks for the values, and the text is typed at the prompt for you to read and run: TermZip never presses Enter.
• Your project's tasks, one keystroke away. The scripts of package.json, Cargo's commands, Makefile targets, justfile recipes and deno.json tasks are in the palette for the folder you are in, typed (not run) when chosen. A profile can be tied to a folder, so a new terminal there uses it.
• SSH and WSL profiles. A tab that opens already connected, with ssh and your own agent and ~/.ssh/config: TermZip stores no key, password or identity file. On Windows, a profile can open a WSL distribution.
• Git where you look, never the network. The branch, how far it is from its upstream and whether files changed, in the status bar, and Open the repository in the browser in the palette. It runs git on your computer and can be turned off.
• Zinc & blue by default. A calm, high-contrast visual system with complete dark and light themes.
• Accessible. Optional screen reader support, no motion when the system asks for none, and every color of the interface held to WCAG AA contrast in every theme, imported ones too.
• Updates only when you ask. Check for updates in Preferences shows the version and notes; installing needs a click and a signature that matches the key built into the app. Nothing is checked in the background unless you turn it on.
• Stable from 1.0. The settings file, the saved layout, the theme format and plugin API 1 are promised to keep working through 1.x.

Screenshots

_{Dracula, one of the twelve built-in themes, with three plugins running: a red exit 2 and an amber slow label on the blocks, a message when sleep 11 ends, and 2 failed in the status bar.}

_{Preferences → Appearance. Every theme is previewed in its own colors, and the window follows your choice before you save.}

_{Catppuccin Latte with the command palette (⇧⌘P): every action, tab, profile, and theme, and the commands of your plugins, marked as such.}

_{A snippet with a value to fill in (⇧⌘S). The text is typed at the prompt and waits for you to read it and press Enter; TermZip never presses it for you. The status bar shows the git branch, two commits ahead, with changed files.}

_{Searching for build in a project folder: the tasks of its Makefile, justfile and package.json (with the package manager it uses), typed and never run.}

_{Preferences → Profiles. An SSH profile connects with your own agent and ~/.ssh/config: TermZip stores no key, password or identity file. A profile can also be tied to folders, like API.}

_{Preferences → Plugins → Catalog. The list is checked against a signature before it is trusted, and every plugin shows what it will ask for.}

_{Preferences → General → Updates, here against a local test feed. Nothing is checked until you press the button; the notes are plain text, and installing needs a second click and a signature that matches the key built into the app.}

_{Preferences → Terminal. Screen reader support keeps an accessible copy of the terminal for assistive technology; it is off by default.}

Getting started

Install Rust and Node.js 20+, then:

git clone https://github.com/LuisPeixoto/TermZip.git
cd TermZip/apps/desktop
npm install
npm run tauri dev

Or install a release: brew install --cask luispeixoto/termzip/termzip on macOS, scoop bucket add termzip https://github.com/LuisPeixoto/scoop-termzip && scoop install termzip on Windows, or download a bundle from the releases. Builds are not yet signed with an Apple or Windows certificate; see troubleshooting.

Build a release bundle:

npm run tauri build

On Linux you also need the WebKitGTK development packages (libwebkit2gtk-4.1-dev, libappindicator3-dev, librsvg2-dev).

How command blocks work

TermZip injects a small integration script into zsh, bash, fish, and PowerShell that emits the semantic-prompt protocol (OSC 133). TermZip reads those markers to build blocks — your prompt, aliases, and plugins are untouched. Shells without integration (cmd.exe, tcsh) still work as a plain terminal; only block capture is unavailable.

See docs/shell-integration.md and docs/terminal-compatibility.md for details and current limitations.

Keyboard shortcuts

Action	macOS	Windows and Linux
New tab	⌘T	Ctrl+Shift+T
Close the active pane (the last one closes the tab)	⌘W	Ctrl+Shift+W
Split right / split down	⌘D / ⇧⌘D	Ctrl+Shift+D / Ctrl+Shift+E
Move between panes	⌥⌘ + arrow	Ctrl+Alt + arrow
Next / previous tab	⇧⌘] / ⇧⌘[	Ctrl+Tab / Ctrl+Shift+Tab
Go to tab 1 to 9	⌘1 … ⌘9	Ctrl+Shift+1 … 9
Command palette	⇧⌘P	Ctrl+Shift+P
Insert a snippet	⇧⌘S	Ctrl+Shift+S
Find in the terminal	⌘F	Ctrl+Shift+F
Toggle the blocks rail	⌘B	Ctrl+Shift+B
Restart the shell	⌘R	Ctrl+Shift+R
Preferences	⌘,	Ctrl+,
Copy / paste / select all in the terminal	⌘C / ⌘V / ⌘A	Ctrl+Shift+C / V / A

On Windows and Linux the application shortcuts use Ctrl+Shift, so plain Ctrl+R (reverse search), Ctrl+B and the other Ctrl keys always reach your shell. Ctrl+C still interrupts the running command. Every shortcut can be changed in Preferences → Keyboard (see keyboard).

Documentation

Guide	What it covers
Configuration	Where settings live, every option, TERMZIP_HOME, what happens to a broken file.
Tabs and panes	Tabs, splits, focus, the layout tree, and the limits.
Search and filter	Find in the terminal and filter the blocks.
Links	What is recognized, what opens, and why a click never starts a program.
Themes	The gallery and its credits, importing and exporting, the theme file, and how the interface colors are derived.
Appearance	Cursor, spacing, window opacity and blur on each system, and per-profile looks.
Keyboard and command palette	Every default shortcut, the editor, [keybindings], and what the palette lists.
Plugins	What a plugin can do, installing from a file or the signed catalog, permissions, and the limits.
Plugin API	For authors: the manifest, the ABI, actions, limits, the versioning policy, and the Rust SDK.
Profiles and restore	Shell, folder, and environment per profile; what is saved between launches.
Snippets	Commands with {{values}}, the palette form, folders, and why a snippet is typed and never run.
Project tasks and folder profiles	The tasks of package.json, Cargo, Makefile, justfile and deno.json, and profiles tied to folders.
SSH and WSL	Profiles that connect, what is stored (nothing secret), what is checked, and the limits.
Git	The status bar item, opening the repository, turning it off, and how a repository you cloned cannot run anything.
Performance and limits	Flow control for floods of output, block events, every bound, and the performance budgets.
Stability	What 1.0 promises to keep, and what it does not.
Accessibility	Screen reader support, reduced motion, contrast, and how they are checked.
Updates	Checking and installing an update, what protects it, and the maintainer's side.
Security review	The attack surface, every input and its bound, findings, and the scope for an independent audit.
Validation checklist	What to check by hand on each system before a release.
Shell integration	The OSC 133 markers, supported shells, and the limits of block capture.
Terminal compatibility	What is implemented, verified, and still missing.
Compatibility matrix	What has been exercised on each operating system.
Architecture	Crates, the session stream, and the design rules.
Troubleshooting	Symptom, cause, and fix for the problems seen so far.
Distribution	Building bundles, the release workflow, signing credentials and the Homebrew, Scoop and Winget channels.
Roadmap	Finished phases and what comes next.

Project structure

Area	Location
Desktop app (Tauri + Svelte + xterm.js)	apps/desktop
Rust shell (sessions, blocks, settings)	apps/desktop/src-tauri
Shell integration and OSC 133 parser	crates/termzip-shell
Cross-platform PTY (ConPTY on Windows)	crates/termzip-pty
Settings and shared tokens	crates/termzip-core
Plugin API types, the host (sandbox, store, catalog) and the SDK	crates/termzip-plugin-api, crates/termzip-plugins, crates/termzip-plugin-sdk
Project tasks and the git state of a folder	crates/termzip-tasks, crates/termzip-git
Tests that need something real (a throwaway sshd)	tools
Example plugins	examples/plugins
App icon source	assets/

Contributing

Issues and focused pull requests are welcome. Read CONTRIBUTING.md for branch naming, Conventional Commits, and the checks every change must pass.

Security

TermZip runs a shell with your user's permissions. Report vulnerabilities privately using GitHub's security advisory form. See SECURITY.md for the current threat model.