# Horizon: a GPU-accelerated terminal board for people running many coding agents

> Horizon places terminal, agent, browser and git panels on an infinite canvas instead of a tab strip. This review covers its workspace model, how to install it, and where the approach breaks down.

**peters/horizon** — GPU-accelerated terminal board that puts all your sessions on an infinite canvas

- Repository: https://github.com/peters/horizon
- Stars: 713 · Forks: 29
- Language: Rust
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/peters-horizon

## The problem Horizon solves: sessions that outlive the tab strip

A terminal emulator gives you tabs. A tiling window manager gives you a grid. Both assume the number of live sessions stays small enough to enumerate, and that assumption fails once you keep a Claude Code session, a Codex session, a dev server, a git diff and a browser preview running at the same time. The tab strip becomes a list of truncated titles, and the thing you were watching ten minutes ago is now three tabs to the left of the thing you are watching now.

Horizon's answer is spatial. Every session is a panel on an infinite 2D surface, and panels are grouped into color-coded workspaces that share a working directory. The README frames it as a whiteboard for live sessions, with structure layered on top: presets that create panels, a command palette that jumps between them, and a fit-to-workspace command for a clean overview. The intended user is not someone who wants one shell. It is someone who runs several agent CLIs in parallel and needs to see which one is still working.

## Canvas, workspace, panel, preset, session: the five nouns

The README reduces the model to five nouns and states that everything else is a shortcut, a preset, or a panel kind. A canvas is the infinite surface, panned with the middle mouse button or Space+drag and zoomed with Ctrl+scroll. A workspace is a color-coded cluster with a shared working directory, arrangeable as free, rows, columns or grid, and detachable into its own OS window. A panel is one live surface inside a workspace. A preset is a named template for a new panel. A session is a saved board, switched with Ctrl+Shift+J.

The panel kinds listed in the README are shell, ssh, browser, editor, git_changes, usage and command, plus first-class entries for Grok, Claude, Codex, OpenCode, Gemini CLI, KiloCode and Pi. That list is the clearest statement of intent in the repository: agent TUIs are treated as panel types, not as commands you happen to type into a shell. Title bars show a working indicator and, when a session is bound to the panel, its session id. Session persistence and resume work, per the README, where the underlying CLI supports it, which is an honest qualification rather than a blanket promise.

The repository layout backs the claim that this is a real application rather than a wrapper. Cargo.toml declares a workspace with nine members, including horizon-core, horizon-ui, horizon-browser and horizon-browser-mcp, and pins edition 2024 with rust-version 1.95. A browser panel is not a webview bolted on: there is a separate protocol crate and a Chrome DevTools Protocol transport over plain ws:// to 127.0.0.1, with tungstenite as the client and a JPEG decoder for change-driven screencast frames.

## Installing Horizon and creating a first workspace

The README links an install section and a releases page, but the cleaned text does not spell out the per-platform commands, so the reliable path from the repository is to take a build from the releases page or build the workspace yourself. The repository carries packaging/, containers/, snap/ and .cargo/ directories, which indicates packaged builds exist, though the README does not describe what each one contains.

Building from source requires the toolchain version declared in the workspace manifest. The file rust-toolchain.toml at the repository root is what pins it, and Cargo.toml states rust-version 1.95.

```bash
git clone https://github.com/peters/horizon
cd horizon
cargo build --release
```

Once Horizon is running, the README says no config file is needed. The first real action is to create a panel on empty canvas. Ctrl+double-click opens a preset list; picking Shell or an agent preset then asks for a working directory, which becomes the workspace cwd and the location of the first panel.

```text
Ctrl+double-click   open the preset list on empty canvas
Ctrl+Shift+N        new panel using the first preset (Shell by default)
Ctrl+Shift+K        command palette; type a preset alias such as gb, cc, web, gc
Ctrl+Shift+9        fit the workspace into view
Ctrl+Shift+W        jump back to the workspace without changing zoom
Ctrl+Shift+,        open Settings
```

Settings edits ~/.horizon/config.yaml while the canvas stays visible behind it, per the README. Closing the app and reopening it restores the session, layout, canvas pan and zoom, and terminal history, which is the behaviour the whole design depends on.

## Where the canvas model costs you something

Spatial layouts trade enumeration for recall. A tab strip tells you exactly how many sessions exist and lets you cycle them in a fixed order. A canvas does not: the README's own advice for an off-screen panel is to pan, zoom, fit, or search, and that is four recovery strategies where a tab list needs zero. The command palette with its @ prefix for panels only and > prefix for presets and actions is the mitigation, and it is a good one, but it is still a search box standing in for a visible list.

There is a second cost in the persistence model. Horizon saves its own session, and the README describes reopening the app to find the board intact. It does not describe attaching to a running Horizon instance from another machine, nor a client-server split, so a session appears to be tied to the machine and the display running it. Anyone whose workflow depends on detaching from a remote host and reattaching later should treat that as unverified rather than assume parity with a terminal multiplexer.

The browser panel deserves the same caution. Running Chromium, Firefox or Safari on the canvas with a shared live page is a strong idea for agent workflows, but the README does not document what happens when the browser process dies independently of Horizon, or how profile state and cookies are isolated between panels. Those are the questions to answer before putting a logged-in production console on the canvas.

## Horizon versus tmux and a tiling window manager

The closest comparison is tmux, and the difference is architectural rather than cosmetic. tmux is a terminal multiplexer with a server process and a client that attaches over a socket; sessions survive disconnection by design, and the entire layout is scriptable from a config file. Horizon is a GPU-rendered desktop application: rendering goes through wgpu and egui, terminal emulation comes from the Alacritty engine, and the unit of organisation is a workspace with a working directory rather than a window with panes. You get 24-bit color, mouse reporting, scrollback, alt-screen and the Kitty keyboard protocol from that engine, and the README notes that a click on a TUI goes to the application while Shift+click still selects text.

A tiling window manager sits at the other end. It manages real OS windows and gives you keyboard-driven geometry, but it has no concept of a workspace cwd, no panel kinds, and no idea that one of your windows is a Claude Code session with a token budget. Horizon's usage panel, which tracks token spend across agent panels, has no equivalent in either alternative. The honest framing is that Horizon trades tmux's detach-and-reattach model and the window manager's universality for a purpose-built view of agent work.

## Maintenance, licence and what upgrading costs

The repository is not archived, and the last push was on 2026-09-10. Releases are infrequent rather than continuous: v0.2.5 on 2026-04-11, v0.2.6 on 2026-05-01, and v0.2.7 on 2026-08-02. That cadence is worth noting if you plan to build from source, because the workspace pins rust-version 1.95 and edition 2024, so an older toolchain will fail before it reaches your code. The workspace lint configuration sets clippy all and pedantic to warn, which suggests the codebase is held to a fairly strict standard, though that says nothing about runtime stability.

Licensing is MIT for the workspace package, and the repository carries a LICENSE file at the root. MIT is permissive: it allows commercial use and modification with attribution and no warranty. That is a description of the licence text, not legal advice, and the bundled browser panel is worth a separate look, since it drives Chromium, Firefox or Safari as external processes and those carry their own licences.

Upgrade cost is tied to the session format. The README presents sessions as durable, but it does not document a migration path between versions, so a format change in a future release is the scenario to plan for. Keeping the config at ~/.horizon/config.yaml under version control is cheap insurance.

## Conclusion

Horizon fits engineers who keep several coding-agent TUIs alive at once and lose track of them in tabs: the canvas, the color-coded workspaces and the usage panel all assume that workflow. Skip it if you want one shell in one window, or if you rely on a terminal multiplexer you already script heavily, because Horizon's persistence is its own session file and the README does not describe an attach protocol. Before committing, check the packaging directory for your platform, confirm your Rust toolchain is at least 1.95 if you build from source, and read the config reference at ~/.horizon/config.yaml.

## FAQ

### What is Horizon?

Horizon is a GPU-accelerated terminal board that places terminal sessions on an infinite canvas. The README describes it as a visual workspace where terminals, coding agents, browsers and editors each live as a panel inside a color-coded workspace.

### How do I install Horizon?

The README links an install section and the releases page, and the repository contains packaging, containers and snap directories. The README text does not list per-platform install commands, so the documented routes are a release build or compiling the Cargo workspace yourself.

### How do I use Horizon to create a panel?

Ctrl+double-click on empty canvas opens a preset list. Choosing Shell or an agent preset then asks for a working directory, which becomes the workspace cwd and the location of the first panel.

## Sources

- [Issues](https://github.com/peters/horizon/issues)
- [License: MIT](https://github.com/peters/horizon/blob/main/LICENSE)
- [peters/horizon on GitHub](https://github.com/peters/horizon)
- [README](https://github.com/peters/horizon/blob/main/README.md)
- [Releases](https://github.com/peters/horizon/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/peters-horizon