A desktop cockpit for coding agents.
Run Claude Code, Codex, GitHub Copilot, Pi, OpenCode, Gemini CLI, Goose, or Runrail's own agent on any model you connect -
each thread in its own worktree, every command and edit behind your approval.
Install · All features · Runrail engine · Security · Changelog
One window for the work, and a whole office to keep track of it.
 Office mode in Sakura: projects, agents, and threads at a glance. |
 Needs attention: approvals waiting for you across projects. |
Runrail Desktop puts your coding agents in one window. Each thread runs on a local, supervised Runrail engine: on Runrail's own agent loop with any model you connect, or on Claude Code, Codex, GitHub Copilot, Pi, OpenCode, Gemini CLI, or Goose through their own sign-ins.
-
Every tool, one workflow. Pick the model for each thread, from your connected providers or the coding tools you already pay for, and see each plan's usage beside the composer.
-
You approve what runs. Plan, Ask, Auto-edit, or Full access, per thread. Approval cards show the exact command or file before anything happens.
-
Parallel by default. Give a thread its own git worktree, run Best of N across models and tools, compare the diffs and check results side by side, and keep the winner.
-
Review and ship. Stage, comment, and commit from the diff view. See every pull request waiting on you, its checks and reviews, and post or merge after you confirm.
-
Works while you're away. Workflows on a schedule or a pull request event, notifications when a thread needs you, and a menu bar item that keeps work running after the window closes.
-
Local and private. No account or network telemetry. Optional usage history is off by default and stays on this computer; prompts, transcripts, paths, and credentials are never included. Keys stay in the system keychain, and the window never holds a credential.
-
Start something new. Create an app from a starter (Nifra, Vite, or Next.js) and open it as a project in one step.
The feature guide covers everything area by area: threads, the composer, reviews, worktrees, imports from other tools, voice, the side panel, workflows, the menu bar, extensions, and the look.
Download the file for your system from the
latest release.
SHA256SUMS.txt there lists each file's checksum.
| System | File |
|---|---|
| macOS 13 or later, Apple silicon | Runrail_<version>_aarch64.dmg |
| macOS 13 or later, Intel | Runrail_<version>_x64.dmg |
| Linux x64 or arm64 | .deb, .rpm, or .AppImage; see docs/LINUX.md |
| Windows 10 or later, x64 (experimental) | Runrail_<version>_x64-setup.exe or .msi |
On macOS, Homebrew installs the same DMG: brew install --cask TechDev009/runrail/runrail.
These builds are not yet signed by a registered developer, so macOS and Windows warn before the first launch:
-
macOS: drag Runrail to Applications and open it. When macOS says it cannot verify the app, choose Done, then open System Settings, Privacy & Security, and click Open Anyway beside the message about Runrail. Or, in Terminal:
xattr -dr com.apple.quarantine /Applications/Runrail.app
-
Windows: when SmartScreen says it protected your PC, choose More info, then Run anyway.
-
Linux: no warning; the packages are unsigned.
Runrail checks the latest release at launch and every six hours. An update downloads only when you click Install and restart, and installs only if its signature matches the key built into the app.
To work with Claude Code, Codex, GitHub Copilot, Pi, OpenCode, Gemini CLI, or Goose, install that tool and sign in to it once; Runrail uses its login as it is. To use a model directly, connect a provider in Settings with a key or a browser sign-in.
Runrail has no account or network telemetry. Optional local usage history is off by default and stores only bounded counts on this computer. It never includes prompts, transcripts, paths, credentials, or account details. Runrail contacts these services only for the features you use:
- the model providers and coding tools you connect, with your own sign-ins. Prompts, selected files, and tool results go to the provider or tool that handles the thread;
- npm, once, to download the Claude Agent SDK after you allow it (Runrail asks before Claude Code's first message);
- GitHub, for the update check, and through your own
ghsign-in for pull requests and CI logs; - the optional GitHub CI relay, when you pair it. GitHub sends signed webhook payloads to the configured Worker; after verification, it stores only event type, repository, pull request number, head commit, optional workflow run details, and timestamp for 24 hours. It does not retain raw webhook payloads, check logs, review comments, or credentials;
- the configured model provider or coding tool, when you click Fix failing checks or enable Watch checks and fix failures. Runrail fetches logs locally, adds selected excerpts to the thread, and sends them to the tool handling that thread. The excerpts remain in the local thread history. The relay never receives the logs;
- Hugging Face, only if you download a Whisper model for local dictation;
- your phone's push service, only if you turn on phone notifications;
- npm, when you start a new app, to fetch that starter's creator at a fixed version.
Provider keys and the relay pairing token are kept in the system keychain (on Linux without a
keyring, in a file only your user can read). GitHub CLI sign-in remains with gh. The app's
database stores which connection a thread uses, never a provider key or relay token. See
SECURITY.md for the trust boundaries.
Nifra is a TypeScript framework made by the authors of Runrail, and the Runrail engine is built on it. The app promotes Nifra in these places and nowhere else, each in plain view and each with a way out:
| Where | What you see | Turn it off |
|---|---|---|
| Create project, New app | Nifra is the first starter, chosen by default and marked Recommended, with "By the authors of Runrail" on its card. Vite + React, Next.js, and Empty sit beside it with their makers. | pick another starter |
| Threads in a Nifra project | Runrail's own agent gets the tools of the nifra mcp on your PATH (docs, examples, and types without asking; anything else asks first), and Pi gets Nifra's instructions and tools. The thread header shows a Nifra label that says what was added; click it for the switch. |
Settings, General, Nifra in Nifra projects |
| Settings, MCP servers | A line saying the Nifra server starts in Nifra projects, with a link to the switch. | the same switch |
A Nifra project is one that depends on Nifra or has a Nifra config file. Other projects get none of
this. Runrail never installs nifra for you and sends nothing about it anywhere. The engine's
README lists the same places for the
command line.
These pass their tests against stand-ins (a fake gh, mock services, a simulated host) but have
never run against the real thing. Expect rough edges, and
report what breaks:
- Posting pull request reviews and merging on real GitHub.
- An integration with a real connector key (Jira, Linear, Slack, and others).
- Phone access and access over a tailnet.
- Computer use with the real macOS permission prompts (Screen Recording and Accessibility).
- "Run schedules after Quit" from an installed build.
- Compaction in the real app.
- The Linux desktop: the tray, the keyring, and Wayland. With no keyring (no Secret Service on the session bus), keys and sign-ins are kept in a file vault that only your user can read, but in plain text, not encrypted.
- The Windows app. CI builds it, but it has never been run.
- The unofficial xAI, Kimi, and Meta plan sign-ins. Each is labelled Unofficial, presents that vendor's own command-line client id, and has never been run against the vendor.
You need Bun 1.3 or newer, Rust, and a
Runrail checkout beside this one. On macOS, local
dictation also needs cmake (brew install cmake) and Xcode's command line tools; Linux needs
the packages in docs/LINUX.md.
bun install
bun run devbun run dev serves the UI on http://localhost:1420. In a plain browser it runs against a
scripted preview engine (marked Preview in the sidebar), so every screen can be exercised
without a model or credentials; the screenshots above come from it.
For the native app, build the bundled engine from the sibling checkout (RUNRAIL_DIR points
elsewhere), then start Tauri:
bun run sidecarbun run tauri devThe sidecar is Runrail compiled without the Claude Agent SDK: the engine downloads the SDK version
bun.lock pins from npm once you allow it (Claude Code's first message asks, and Settings, Agent
has an Install button), and runs the claude you installed. Until then Claude Code runs in print
mode and cannot ask before tools. The window is transparent so macOS can draw the sidebar material behind
it, which needs Tauri's macOSPrivateApi and keeps this build out of the Mac App Store.
bun run typecheck
bun test
cargo test --manifest-path src-tauri/Cargo.tomlbun run e2e:native drives the real app end to end: a debug build under its own identifier
(com.runrail.desktop.e2e) with a home folder of its own, so it needs no model and touches none
of your accounts. --model-runs adds a Best of 2 on Claude Code's Haiku, and --setup-run a
plan, execute, review setup run in a scratch repo; both use your Claude Code login.
scripts/automation.ts drives a debug build started with RUNRAIL_AUTOMATION=1 by hand.
Every push and pull request runs build.yml: typecheck and tests,
then the app for macOS (arm64 and x64), Linux (x64 and arm64), and Windows (x64), each with its
engine built from the Runrail checkout. macOS builds
go through scripts/release.ts mac, which signs the engine and the app with separate
entitlements so only the engine may JIT. A version tag collects every bundle, the signed update
feed, and checksums into a draft GitHub release that stays hidden until it is published by
hand. docs/RELEASE.md has the steps, the signing secrets, and the updater
key.
Issues and pull requests are welcome; see CONTRIBUTING.md. Report security problems privately, as SECURITY.md describes.
Free software under the GNU Affero General Public License, version 3 (AGPL-3.0-only; see LICENSE), with an additional permission to combine it with Anthropic's Claude Agent SDK (see NOTICE). You may use, modify, and redistribute it for any purpose, including commercial work. If you distribute a modified version, or let others use one over a network, you must offer them its source under the same license.