Rook

A minimal, keyboard-driven terminal Emulator for macOS.

Splits, tabs and workspaces that stay out of your way, with just enough help from your shell.

Download for macOS (Apple silicon)

Features · Installation · Usage · Configuration · Documentation · Contributing

Screen.Recording.2026-10-31.at.5.04.58.PM.mov

---

Why Rook

Most terminals either do too little or put everything on screen at once. Rook keeps the window to your shells and moves everything else behind the keyboard: no toolbars, no panels you didn't ask for, and a status line that only speaks up when something matters.

Features

Panes, tabs and workspaces

• Split in any direction and move, resize or close panes with vim keys, or drag the dividers with the mouse.
• Even splits that stay even. Panes form an n-ary tree, so three panes side by side are three equal columns rather than a nested chain.
• Workspaces group tabs by project. Switch with ⌘E or ⌘⌥1–9; shells in background workspaces keep running.
• Session restore. Workspaces, tabs, splits, divider positions and each pane's folder come back exactly as you left them.

Shell integration

• Tabs are titled with the current folder; the status line shows the full path and git branch.
• Failed commands are marked in place, with the command and its output highlighted and the exit code beside it.
• New splits and tabs open in the folder you're in.
• A dot on a tab shows when something is running in it.
• Works with your existing .zshrc, prompt and plugins. Rook loads them as usual and adds its hooks without editing any of your files.

Appearance

• Four themes: Nara, Tokyo Night, Rosé Pine and Catppuccin Mocha, each covering both the terminal palette and the interface.
• Five fonts: JetBrains Mono, Geist Mono, Fira Code (with ligatures), IBM Plex Mono and SF Mono, bundled so they work offline.
• Separate sizes for the terminal and the interface, like an editor's buffer and UI fonts.
• Changes apply live, to every open terminal, without restarting a shell.

Footprint

Rook is a 2.5 MB download and 4.6 MB installed, because it uses the web engine built into macOS instead of bundling its own.

	Installed size	Memory, one window and one shell
Rook 0.1.4	4.6 MB	~167 MB
Terminal.app	3.5 MB (built in)	~53 MB
iTerm2	194 MB	~159 MB
Ghostty	62 MB	~240–300 MB

_{Measured on an Apple silicon Mac with macOS's footprint tool (the figure Activity Monitor shows as Memory), with each app freshly opened. Totals include each app's helper processes, but not the shell itself. For Rook that means its WebKit processes, which Activity Monitor lists separately from Rook. Numbers vary with what's on screen.}

Performance

Terminals draw with the GPU (WebGL), at your display's full refresh rate, and each pane's output reaches it as raw bytes on its own channel. Typing never waits on output from other panes.

Benchmark	Result
Keystroke echo through the PTY	~10 µs
Program output through the PTY	~115–150 MB/s
Parsing colored output, Unicode, nvim-style redraws	~100–125 MB/s
Parsing plain lines (cat of a big log)	~40–47 MB/s
Laying out 16 panes	~1 µs

_{bun run bench on an Apple M4. The backend moves output about 3× faster than xterm.js can parse it, so parsing is the limit, and plain line output, which scrolls on every line, is the worst case. A keystroke's round trip through the PTY is a tiny fraction of one display frame.}

The benchmarks are reproducible: fixed, seeded inputs, pinned versions, and a comparison that tells real changes from noise. Measure a change before and after with:

bun run bench --save before

bun run bench:compare bench/results/before.json bench/results/after.json

To compare Rook with other terminals end to end, rendering included, run zsh bench/terminal.sh inside each one. See Benchmarks.

Installation

Download

Download Rook_0.1.7_aarch64.dmg (Apple silicon), open it, and drag Rook into Applications. Other versions are on the Releases page.

Rook isn't notarized by Apple yet, so macOS blocks the first launch with a warning that it can't verify the app. To open it anyway:

1. Open Rook from Applications once, and dismiss the warning.
2. Go to System Settings → Privacy & Security, scroll down, and click Open Anyway next to the message about Rook.

Or clear the quarantine flag from a terminal, which skips the warning entirely:

xattr -dr com.apple.quarantine /Applications/Rook.app

Copy Rook into Applications before opening it; don't run it from the disk image.

Build from source

You'll need:

• macOS
• Bun
• Rust (stable)
• The Tauri prerequisites for macOS (the Xcode Command Line Tools)

Clone the repository and install dependencies:

git clone git@github.com:Aneeshie/rook.git

cd rook && bun install

Run it in development mode:

bun run tauri dev

Build a disk image (.dmg) for your Mac's architecture:

bun run build:dmg

The image is written to src-tauri/target/release/bundle/dmg/, for example Rook_0.1.7_aarch64.dmg on Apple silicon. To also keep the .app (in bundle/macos/), build every bundle format instead with bun run tauri build.

Usage

Rook is designed to be driven from the keyboard. Directions use vim keys: h left, j down, k up, l right.

Keys	Action
⌘T	New tab
⌘1 – ⌘9	Go to tab (⌘9 is the last)
⌘⌥ h j k l	Split the pane in that direction
⌘⇧ h j k l	Move focus to the neighbouring pane
⌘⌃ h j k l	Resize: move the nearest divider
⌘W	Close the pane
⌘E	Switch, create or rename workspaces
⌘⌥1 – ⌘⌥9	Go to workspace
⌘+ / ⌘− / ⌘0	Terminal font size up / down / reset
⌘,	Settings
⌘/	Show all shortcuts

See docs/keybindings.md for the complete reference.

Configuration

Open Settings with ⌘, or the gear in the status line to choose a theme, a font, and the terminal and interface sizes. Everything applies immediately and is remembered between launches.

Adding a theme takes a single object in src/theme.ts; see docs/configuration.md.

Documentation

Guide	Contents
Architecture	How the Rust backend and React frontend fit together: commands, events and state
Pane layout	The split tree, its invariants, and the math that lays it out
Shell integration	How zsh reports folders, branches and command results
Keybindings	Every shortcut, and how to add one
Configuration	Themes, fonts and sizes, and adding your own
Development	Project structure, commands and conventions
Benchmarks	Measuring performance reproducibly, and comparing runs or terminals

How it works

Rook is a Tauri 2 application. A Rust backend starts each shell in a pseudo-terminal with portable-pty and streams its output to a React frontend, which renders it with xterm.js. Shells report their folder, branch and command results through standard escape sequences (OSC 7 and OSC 133), the same mechanism used by iTerm2 and VS Code. The architecture guide covers the details.

Roadmap

• Split panes, tabs and workspaces
• Session restore
• Shell integration: folders, branches, command status
• Themes, fonts and settings
• macOS disk image
• Signed and notarized releases
• Search in scrollback
• Command palette
• AI assistant: explain a failed command and suggest a fix
• Sessions that keep running after the app quits
• Support for shells other than zsh

Contributing

Contributions are welcome. To propose a change:

1. Fork the repository and create a branch.

2. Make your change, following the conventions in docs/development.md.

3. Check that it builds and the tests pass. CI runs both on every pull request:

   bun run build

   bun run test

4. If the change could affect speed, compare bun run bench before and after (see Benchmarks).

5. Try it in bun run tauri dev, then open a pull request describing what changed and how you tested it. Include a screenshot for visual changes.

Commit messages follow Conventional Commits: feat:, fix:, docs:, chore:.

License

Rook is released under the MIT License.