Run claude, codex, antigravity, opencode and more in parallel. Each in its own git worktree.

Every new feature the day they ship it: the real CLIs on your own Pro / Max plan, no vendor backend.

Install · What it does · Sandbox · vs. Conductor · Contributing

Termic is a free, open-source desktop app that runs your AI coding-agent CLIs side by side, each isolated in its own git worktree, with an optional per-workspace macOS sandbox cage. It spawns the real claude, codex, agy (Antigravity), copilot and grok binaries (not the vendor SDKs), so inference rides on the Pro / Max plan you already pay for. Spin up four agents on the same branch, broadcast one prompt to all of them, watch a reliable work-done indicator tell you the moment each finishes.

The recommended path is Homebrew + the official tap:

brew install --cask simion/termic/termic

That single command auto-taps simion/homebrew-termic, downloads the latest .dmg, and installs Termic.app into /Applications. Termic is signed with a Developer ID certificate and notarized by Apple, so there's no Gatekeeper warning.

Updates: Termic ships with a self-updater. When a new release lands you'll see an Update X.Y.Z pill in the top-right of the toolbar; click it to download + verify + relaunch. To check manually:

brew upgrade --cask termic

.dmg, .app.tar.gz, and the ed25519 signature for each version live at the Releases page. The .dmg is signed and notarized by Apple, so it opens on first launch with nothing else to do.

Download termic_<version>_amd64.AppImage from the Releases page, make it executable, and run it:

chmod +x termic_*_amd64.AppImage
./termic_*_amd64.AppImage

The AppImage is ed25519-signed by the same CI flow as the macOS build, so the in-app updater works the same way: a new release appears as the Update X.Y.Z pill in the top-right, click to download + verify + relaunch. Keep the AppImage somewhere writable like ~/Applications/ so the updater can replace it in place.

The sandbox feature is macOS-only on Linux: the workspace's Shield toggle is disabled and agents run unsandboxed. Everything else (worktrees, parallel tabs, find-in-files, themes, in-app diff) works the same.

Wayland note: if fonts render thin, force X11 with GDK_BACKEND=x11 in front of the launch command (or in the .desktop file's Exec=).

git clone https://github.com/simion/termic
cd termic
make setup          # brew/rust/node + npm install + cargo check
make install        # build, copy to /Applications, launch

make dev (vite HMR + Rust auto-rebuild) is the iteration loop — see CONTRIBUTING.md if you plan to hack on the code.

The signed AppImage on the Releases page is the recommended path for most users — see Linux (AppImage) above. Build from source if you want to hack on it, ship a .deb / .rpm for your own distro packaging, or run an unreleased commit.

Prerequisites — Debian / Ubuntu (24.04+ has WebKitGTK 4.1):

sudo apt update
sudo apt install -y \
  build-essential curl wget file git pkg-config \
  libwebkit2gtk-4.1-dev libgtk-3-dev libayatana-appindicator3-dev \
  librsvg2-dev libssl-dev libsoup-3.0-dev libxdo-dev

# Rust stable
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
. "$HOME/.cargo/env"

# Node 20+ — distro package, nvm, fnm, asdf, or mise (whichever you use)

Fedora:

sudo dnf install -y \
  @development-tools curl wget file git pkgconfig \
  webkit2gtk4.1-devel gtk3-devel libappindicator-gtk3-devel \
  librsvg2-devel openssl-devel libsoup3-devel libxdo-devel

Arch:

sudo pacman -S --needed base-devel curl wget file git pkgconf \
  webkit2gtk-4.1 gtk3 libayatana-appindicator librsvg openssl libsoup3 xdotool

Build and install:

git clone https://github.com/simion/termic
cd termic
npm install
npm run tauri build           # ~5 min first time, faster on incremental

The bundles land under src-tauri/target/release/bundle/. Pick whichever fits your distro:

# Debian / Ubuntu / Pop / Mint
sudo apt install ./src-tauri/target/release/bundle/deb/termic_*_amd64.deb

# Fedora / RHEL / openSUSE
sudo dnf install ./src-tauri/target/release/bundle/rpm/termic-*.x86_64.rpm

# Distro-agnostic — no install needed, just make it executable and run
chmod +x src-tauri/target/release/bundle/appimage/termic_*_amd64.AppImage
./src-tauri/target/release/bundle/appimage/termic_*_amd64.AppImage

After the .deb / .rpm install, "Termic" shows up in your application launcher. The in-app updater only knows how to replace the AppImage in place — .deb / .rpm users upgrade via git pull && npm run tauri build

• reinstall.

If the window looks slightly off — an empty gap on the left of the top bar, for example — that's the 84px reservation for macOS traffic-light controls. Harmless, will be cleaned up when the cross-platform chrome lands.

Wayland note: if fonts render thin, force X11 with GDK_BACKEND=x11 termic (or set it in the .desktop file's Exec=).

Same story: no prebuilt binaries, build works, sandbox is a no-op. On Windows 11 (or Windows 10 with WebView2 Evergreen installed):

1. Install Microsoft C++ Build Tools (the "Desktop development with C++" workload).
2. Install Rust stable (rustup).
3. Install Node 20+ and Git for Windows.

Then in PowerShell:

git clone https://github.com/simion/termic
cd termic
npm install
npm run tauri build              # → src-tauri\target\release\bundle\msi\

The .msi is unsigned — Windows SmartScreen will warn on first run. Click More info → Run anyway (or sign it yourself for distribution).

See CONTRIBUTING.md for the full dev guide.

Every agent runs inside a real PTY, the same binary you'd launch in iTerm, so there's nothing between you and the CLI. No vendor SDK (which bills against a separate credit pool as of June 2026), no metered markup, no backend daemon. Here's what the window gives you on top:

• Parallel worktrees. Each workspace is a git worktree under ~/termic/workspaces/<project>/<name>/. Run N agents against the same branch across tabs; attach to repo root when you don't want a worktree; duplicate a worktree to spin up a parallel attempt off the same tip.
• Command palette (⌘K). Search and run any action — new workspace, file picker, find-in-files, rename, archive, YOLO, sandbox, theme, sidebars, settings — from one place, each with its shortcut inline. ⌘N is a quick project picker: fuzzy-find any repo and start a workspace without touching the sidebar.
• Multi-repo workspaces. Group N repos (backend, frontend, infra) under one workspace with a shared CLAUDE.md and per-member dev-server ports. File finder, find-in-files, and the diff view span every member.
• Broadcast & Brainstorm. Send a single prompt to every agent in a workspace concurrently (⇧⌘B). Perfect for multi-agent code reviews, architectural brainstorming, or getting four "second opinions" on a complex bug in seconds.
• Config as Code (.termic.yaml). Persist all project-specific settings—setup scripts, run commands, preview URLs, and sandbox allowlists—into a .termic.yaml file. Commit it to your repo so your whole team gets the same optimized agent environment instantly.
• Per-workspace sandbox (macOS). Filesystem + network cage via sandbox-exec and an in-process HTTPS CONNECT proxy with a hostname allowlist. Lets the agent run with --dangerously-skip-permissions safely — the cage is the boundary, not the prompt.
• Sidebar Cockpit. Expand any workspace in the sidebar to see all its active agents, their live work-done indicators, and their agent-managed titles at a glance.
• Work-done indicator that's actually reliable. Per-CLI title classifier (Claude spinner, etc.) plus OSC 9;4, gated by byte-quiet and content-hash checks. This reliability enabled opt-in desktop notifications that only fire when an agent actually finishes a turn.
• Message Queues. Built on top of work-done detection: queue N messages (with optional repeats) to run autonomous "Ralph loop" sessions.
• Auto-Resume Everything. Termic auto-resumes sessions even for repo-root workspaces. The latest update now auto-resumes ALL agent tabs in a workspace, not just the primary one.
• Spotlight. Mirror one worktree's changes — committed, uncommitted, and untracked — into your repo root in real time, so your editor, dev server, and browser see the agent's work live. It runs on a detached HEAD and never commits to your branch; disabling it cleanly restores the checkout. (Conductor checkpoints your branch; Spotlight doesn't touch it.)
• Find + edit in-app. ⌘P fuzzy file finder, ⇧⌘F find-in-files (git grep, .gitignore-aware, streams live). CodeMirror 6 editor with side-by-side / unified diffs and Markdown preview (including inline Mermaid diagrams).
• Fork-style Git UI. A dedicated staging area inspired by the Fork app. Stage, unstage, and commit without dropping to a terminal.
• AI review: open the Review dialog, pick an agent, it gets the diff
  • a review prompt and starts streaming. Or leave GitHub-style inline comments on the diff yourself — they batch into one message and fire to the agent on send.
• Prompt library. Save reusable prompts and fire them at a running or fresh agent from the top menu. Ships with Review, Write tests, Security review, Explain changes, and Commit; queues automatically if the agent is busy.
• Bring your own agent. Settings → Agents is an editable registry. Drop in aider, ollama, a shell script — 30 seconds. Claude, Codex, Antigravity, Copilot, Grok, and opencode ship as built-ins.
• Keyboard-first. ⌘K command palette, ⌘1..9 swaps tabs, ⌥↑/↓ walks the visible sidebar tree, ⌥⌘↑/↓ hops workspace-only, ⌘D / ⇧⌘D split right / bottom, ⌘T spawns a new tab, ⌘W closes one. Every shortcut is rebindable in Settings → Shortcuts (⌘/ for the searchable cheat sheet). Seven themes (System, Light, Claude, Dark+, Solarized Dark, Cobalt, Matrix), each re-themes both chrome and the terminal pane. Or bring your own: drop a JSON file in the themes folder and it appears in the picker as a first-class theme — see docs/themes.md.
• Terminal niceties. xterm.js + WebGL, OSC 52 clipboard (copy out of a container or over SSH), optional copy-on-select, inline images, clickable links, and drag-and-drop file paths.

Optional per-workspace macOS Seatbelt (sandbox-exec) + an in-process HTTPS CONNECT proxy per workspace. Configured per project, pinned per workspace at creation (editable later from the workspace's Shield icon), enforced from the moment the agent spawns.

The cage:

• Writes restricted to the worktree, agent config dirs (~/.claude, ~/.codex), package caches (~/.npm, ~/.cache, ~/.cargo/registry), and TMPDIR. Always-denied: ~/.ssh, ~/.aws, ~/.gnupg, ~/.netrc, ~/.docker/config.json, ~/.kube, Keychains.
• Network restricted via an in-process CONNECT proxy with a regex hostname allowlist. Per-CLI vendor APIs (anthropic / google / openai)
  • GitHub + npmjs + PyPI + crates.io baked in. Add custom hosts per project. No external daemon — the proxy lives inside the Tauri binary, so there's nothing extra to install.
• YOLO auto-on inside the cage. The seatbelt profile IS the security boundary, so the agent's own permission prompts are skipped. The toolbar lightning icon turns red when YOLO is on without a sandbox (intentional danger signal — agents can rm -rf $HOME at that point).

For the full sandbox design — including the recent-denies debug panel and the auto-restart-on-edit flow — see CLAUDE.md §"Sandbox".

• macOS: first-class — universal binary (Apple Silicon + Intel), signed updater, Homebrew cask. Requires macOS 12+ (Monterey).
• Linux: x86_64 AppImage shipped per release, signed by the same ed25519 key as the macOS build so the in-app updater works. ARM Linux + a Flathub submission are on the roadmap.
• Windows: build-from-source works today (Tauri 2 + WebView2). No prebuilt binaries yet — CI matrix entry is on the roadmap.
• Sandbox: macOS-only (sandbox-exec is Apple's frontend to Seatbelt). On Linux + Windows the Shield toggle is disabled and agents run unsandboxed.

The honest pitch — see termic.dev/vs/conductor for the full version with explanations.

If you already pay for a Claude Pro / Max plan, Termic spawns the same claude binary that plan covers — no separate metered usage, no per-token markup. The agent and Anthropic still see the same auth they'd see in iTerm.

Open an issue to push something up the list or pick one off.

1. Code intelligence via language server plugins. Cmd-click go-to-definition, find class / symbol, hover types, inline diagnostics. Pluggable language server plugins (rust-analyzer, typescript-language-server, pyright, gopls and others) resolved from the user's toolchain automatically. A fast heuristic (ripgrep + tree-sitter) pass for all languages, then real LSP where a server is present. (#174)
2. Mobile app. A companion mobile application for remote control and monitoring of tasks on the go.
3. MCP Server Integration. Add support for Model Context Protocol (MCP) servers to supply rich context directly to agents (currently being worked on by a contributor).
4. Linear + GitHub PR integration. Paste an issue / PR URL, get a workspace seeded with title + body. Create the PR from the app via gh. No OAuth.
5. Sandbox parity on Linux + Windows. macOS Seatbelt today; bubblewrap / landlock on Linux and AppContainer on Windows are the gap.
6. Docker-based sandboxing. An opt-in, more brutal alternative to Seatbelt: run each agent inside a container off a default, editable Dockerfile that ships the supported agents. Install whatever your agents need in the image; they cannot escape it and only see the paths you mount (just the project repo(s) by default, everything else installed but not mounted). Cross-platform for free, and pairs well with per-agent credential injection (or a single CLI login) so you need not mount secrets at all. See #49 for the kind of host-toolchain friction this sidesteps.
7. Windows prebuilts. AppImage CI is live for Linux; Windows MSI is the matching CI matrix entry.
8. Opt-in usage telemetry. Anonymous, opt-in analytics via a self-hosted Umami instance. Strictly limited to usage patterns (which features are used, how often) and crash reports — nothing else. No code, no prompts, no file paths, no agent output, no project names. Minimum viable event set: the goal is performance and feature prioritization, not surveillance. Off by default, one toggle in Settings.
9. Investigating agent lifecycle hooks. Termic infers "the agent finished" from the terminal stream (OSC progress sequences and window titles), which costs no config, works for every agent including ones you add yourself, and keeps working inside the sandbox. Every supported CLI now also exposes a lifecycle hook system that states it outright, with a payload carrying the assistant's closing message, whether the agent is blocked on a permission prompt or on a question, and a warning before context compaction. Whether that is worth writing into your agent config is an open question, so the first step is measuring hooks against OSC across the scenarios that actually break detection (interrupts, permission prompts, subagents, compaction). If it earns its place it ships opt-in and off by default, with a real uninstall, and OSC stays authoritative regardless. Research and measurement plan in docs/research/agent-hooks.md.
10. Intentional agent-driven orchestration. The plumbing already ships: agents get TERMIC_CLI and a tutorial in their environment, so a running agent can spawn a task with --wait, prompt another one, read its result and branch on the exit code. What is missing is intent. Environment variables are passive, nothing puts that surface in the model's context, and termic has no opinion about shape (fan out, queue behind, supervisor and workers). Researching whether to put the surface in the agent's context the way Spotify's Xirp does, or to wait for the MCP endpoint where the schema is the documentation, and how much orchestration the tool should suggest rather than obey. Notes in docs/research/agent-orchestration.md.
11. Import Warp and Ghostty themes. Termic has a native JSON theme format, so a custom theme is a file drop away, but two large theme ecosystems already exist and neither is ours. Scan ~/.warp/themes and Ghostty's theme directory, translate both into termic's format, and let people pick from the library they already collected. Borrowed from Orca, which does the import well and, unlike termic, has no native theme format underneath it.
12. On-device dictation for agent prompts. Prompts to a coding agent are prose, not code: a paragraph of intent, constraints and a bit of context. That is the kind of text people speak faster than they type, and it is worth more here than in a normal editor because one dictated prompt can be broadcast to four agents at once. macOS 26 (Tahoe) ships SpeechAnalyzer and SpeechTranscriber in the Speech framework, which run entirely on device against the Apple Silicon Neural Engine, no network and no vendor key, which is the only way a feature like this belongs in an app that is otherwise wholly on-device. Early third-party measurements put it well ahead of Whisper on speed (a 34-minute file transcribed in about 45 seconds, roughly 55% faster than MacWhisper's Large V3 Turbo), though those are other people's numbers on other people's hardware and the interesting figure for us is streaming latency for a 20-second utterance, not bulk throughput. Hard constraints: macOS 26+ and Apple Silicon only, so this is strictly additive, hidden rather than degraded everywhere else (Intel, older macOS, Linux, Windows), and never on the critical path of typing a prompt. Open questions before any of it is worth building: whether the speech models arrive as downloadable assets on first use and what that means for a first run offline, what streaming partial-result latency actually feels like inside a terminal-focused UI, how a Swift bridge is best shaped from the Rust side, how microphone TCC interacts with the sandbox, and whether DictationTranscriber is a good enough fallback for unsupported languages to bother with. Research first: the question is whether it earns a permission prompt and a platform-specific code path, not how to build it.

Termic is free, AGPL-3.0, and built by its author and a growing group of dedicated open-source contributors. If your team builds on AI coding agents and finds it useful, sponsoring helps keep it moving.

Also sponsoring: Vyttle, Sage Haven.

AGPL-3.0-or-later. Fork it, modify it, build a derivative — the only string is that derivatives stay AGPL too. The "open core that quietly went proprietary" pattern can't happen with this license, which is most of the point.

• Website: termic.dev
• Issues: github.com/simion/termic/issues
• Releases: github.com/simion/termic/releases
• Homebrew tap: github.com/simion/homebrew-termic
• Contributing: CONTRIBUTING.md
• Architecture notes (for hackers + AI agents working in this repo): CLAUDE.md