Horizon
- Overview
- Horizon is a GPU-accelerated terminal board that reimagines how you work with multiple terminals by presenting them on an infinite 2D canvas. Instead of being limited to a stack of tabs or a fixed grid, you can place, resize, and group terminal panels across boundless space, turning your terminal sessions into a flexible, visual workspace.
- The core idea is to replace the traditional tabbed or tiled approach with a canvas where each terminal panel becomes a freely movable object. This enables you to organize related tasks, tools, and processes into cohesive workspaces that you can zoom, pan, and rearrange as your project evolves.
- Workflows are designed around structure and discovery: start from color-coded workspaces, launch presets for common panel configurations, and use quick navigation to move between contexts without losing sight of the larger picture. Horizon also preserves what you’re doing so you can resume where you left off—exactly as you left it.
- Visuals and Imagery
- The project presents a bold banner that communicates the concept of “Your Terminals, One Canvas.” This hero image anchors the experience and invites you to imagine terminals as autonomous panels within a living canvas. Image: Horizon banner (assets/hero-banner.svg).
- A live demonstration reinforces the interactive nature of Horizon. The demo GIF shows how a user can pan across AI Agents, Dev, and Monitoring workspaces, highlighting the fluidity of moving panels, switching contexts, and maintaining an overarching view of the entire canvas. Image: Horizon demo (assets/demo.gif).
- Why Horizon? The Problem It Solves
- Traditional terminal layouts—tabs and tiled grids—tend to constrain your workflow. Tabs can hide work too easily, forcing you to switch contexts repeatedly. Tiled layouts, while organized, can box you in and restrict how you visualize related tasks.
- Horizon answers with a canvas that is both expansive and structured. It acts as a whiteboard for terminal sessions, offering a hierarchy of organization (workspaces) and a flexible surface for placing, resizing, and grouping terminals. The emphasis is on maintaining clarity and flow, not on forcing you into a fixed arrangement.
- The result is a workflow where you can simultaneously view and interact with multiple streams of work, move panels to reflect changing priorities, and keep everything visible and accessible without losing context.
- Highlights (Reimagined as a Guided List)
Infinite Canvas and Navigation
You can pan and zoom freely across a boundless workspace. The canvas remains responsive, letting you place terminals anywhere and adjust the scale to focus on details or to get an overview.
A minimap sits in a corner to help you maintain orientation. Clicking the minimap lets you jump to different parts of the canvas quickly, ensuring you never lose your sense of where you are on the surface.
The interaction model supports intuitive navigation: middle-mouse drag or space-plus-drag to pan, Ctrl+Scroll to zoom around the cursor, and direct clicking to jump to sections of interest.
Workspaces and Color-Coded Organization
Workspaces group related panels into color-coded regions, providing a visual taxonomy for your tasks. You can auto-arrange panels within a workspace using three layout modes: rows, columns, or grid. Alternatively, you can drag panels freely to compose a custom arrangement that suits your current workflow.
The workspace header controls empower you to switch between structured layouts or to dissolve the structure temporarily for exploration, preserving the arrangement you’ve built when you return to it.
Full Terminal Emulation on a Modern Engine
Horizon delivers 24-bit color, mouse reporting, scrollback, alt-screen, and compatibility with the Kitty keyboard protocol. The rendering backbone is the Alacritty terminal engine, known for speed and fidelity, ensuring a highly responsive and authentic terminal experience within the canvas panels.
AI Agent Panels and Integrations
Horizon features first-class integrations with AI agents such as Claude Code, Codex, OpenCode, Gemini CLI, and KiloCode. These panels enable you to run AI-assisted tasks directly alongside your terminal work.
Session persistence and resume are supported wherever the respective agent CLI provides it, allowing you to continue working across restarts and interruptions without losing critical context.
A live usage dashboard tracks token spend across agents, giving you visibility into AI costs and usage patterns as you collaborate with AI tools.
Git Integration and Background Monitoring
A built-in git status panel watches your repository in the background, displaying changed files, inline diffs, and hunk-level details without requiring you to context-switch to a separate terminal. This keeps you informed about the evolving state of your codebase while you work on other tasks on the canvas.
Smart Detection and Interaction
Horizon “sees” what your terminal prints and makes it interactive. Features such as Ctrl+Click enable quick actions like opening a URL or a file path under the cursor, reducing friction and speeding up navigation.
The interface supports smart highlighting and hover interactions that reveal useful metadata or quick actions for elements on the canvas.
Remote Hosts and Connectivity
A powerful remote-hosts overlay (Ctrl+Shift+H) discovers hosts from SSH configs and Tailscale. You can search, filter, and connect quickly, and remote sessions can be grouped into a dedicated Remote Sessions grid workspace for a holistic view of distributed work.
Live Settings Editor and Instant Preview
The settings editor is a live editor that opens a YAML-config panel with syntax highlighting and real-time preview. Changes you make apply instantly to the canvas, letting you prototype configurations on the fly and see immediate results.
Session Persistence and Markdown Capabilities
Horizon saves and restores your entire canvas state: workspaces, panel positions, scroll positions, and terminal history are preserved across sessions, so your investigative or development work remains intact over time.
You can also drop a Markdown file onto the canvas or create one from the command palette. The editor features a split view with syntax highlighting and live preview, and you can save Markdown documents to preserve your notes alongside your terminal work.
- Install Options and Platform Support
- Horizon is designed to be approachable through multiple distribution channels, making it straightforward to adopt in your preferred environment.
- Direct download: Grab the latest release from the releases page, which provides binaries and installers without additional dependencies.
- Linux x64: horizon-linux-x64.tar.gz
- macOS arm64: horizon-osx-arm64.tar.gz
- macOS x64: horizon-osx-x64.tar.gz
- Windows x64: horizon-windows-x64.exe
- Managed updates and installers: Surge installers provide a streamlined path for managed stable updates.
- Package managers for convenience:
- Homebrew (stable releases) on macOS and Linux x64 via the peters/horizon tap. Commands are provided to install, upgrade, or uninstall Horizon, with apt-like syntax for familiarity.
- WinGet (Windows Package Manager) entries enable installation, upgrading, or removal via the official catalog, once manifests are approved.
- Snap Store releases for Linux x64 offer classic confinement, enabling Horizon to launch host shells and tools like ssh, git, xdg-open, pgrep, lsof, and optional tailscale helpers without breaking workflows.
- Build from source: Developers can clone the repository, ensure Git LFS is installed for bundled assets, and build using cargo. This path requires Rust 1.88+ and Linux system headers for GPU rendering (per the AGENTS.md prerequisites).
- Notes on updates: Horizon’s Surge installer path supports in-app prompts for upgrades; other package managers handle updates through their own flows.
- Quick Tour: Daily Interaction Patterns
Keyboard shortcuts provide a consistent, efficient workflow
Most shortcuts use Ctrl+Shift to avoid conflicts with shell programs and OS bindings.
Canvas zoom and navigation follow common conventions: Ctrl+0 resets zoom, Ctrl+Plus zooms in, Ctrl+Minus zooms out, with F11 commanding fullscreen on the active panel, and Escape exiting panel fullscreen.
A detailed set of shortcuts enables rapid access to workspaces, terminals, and configuration options. For example, Ctrl+Shift+K quickly navigates to any workspace, Ctrl+Shift+N creates a new terminal panel, Ctrl+Shift+W focuses the active workspace, and Ctrl+Shift+9 fits the active workspace into view.
Settings editing, remote hosts access, and other actions are mapped to easy-to-remember combinations, designed to minimize friction during rapid development cycles.
Structured workflow: a practical sequence to create and manage workspaces
- Create a workspace from the toolbar or by double-clicking the canvas with Ctrl+double-click.
- Add a terminal to the first preset using Ctrl+Shift+N.
- Jump between workspaces quickly with Quick Nav (Ctrl+Shift+K).
- Refocus the current workspace with Ctrl+Shift+W or fit it into view with Ctrl+Shift+9.
- Use workspace header controls to switch between Rows, Cols, and Grid layouts if you want a structured arrangement without leaving the canvas.
- Mouse actions and interaction patterns that complement keyboard control
- Middle-mouse drag or Space plus left-click drag to pan the canvas.
- Minimap click-and-drag to reposition the viewport.
- Ctrl+Click opens the URL or path under the cursor, while Ctrl+Double-Click on the canvas creates a new workspace; Ctrl+Double-Click inside a workspace adds a new terminal.
- On macOS, the same actions are available with Cmd in place of Ctrl, ensuring familiar behavior for Apple users.
- Configuration and Personalization
- Horizon’s settings editor is designed to be a live configurator that writes back to the user’s config file, typically located at ~/.horizon/config.yaml, with optional support for config.yml if discovered or provided.
- Key configuration areas include:
- Shortcuts: a detailed mapping of commands to keyboard combinations, allowing you to customize the command palette, new terminals, focus behavior, remote hosts, toggles (sidebar, HUD, minimap), alignment, and zoom controls.
- Workspaces: definitions of named workspaces with their respective panel presets and the arrangement of panels inside each workspace.
- Presets: named presets that describe panel compositions (e.g., a shell panel, Claude Code panel, OpenCode panel, and Git Changes panel) organized under “Backend” and “Frontend” sections or similar groupings.
- Features: flags to enable or disable UI features such as the attention feed, providing a lightweight customization path for different workflows.
- YAML-based configuration encourages readability and quick tweaking, with explicit examples illustrating how to set up shortcuts, workspaces, and presets.
- Build and Technology Stack
- Horizon is built using a modern, multi-layer stack focused on performance and UI responsiveness:
- Rust: The core language driving logic, performance, and safety, with an emphasis on maintaining a clean architecture and fast execution.
- eframe / egui: The immediate-mode UI framework used to render the Horizon canvas and its interactive components, delivering responsive and fluid controls.
- wgpu: The GPU rendering engine responsible for cross-platform support across Vulkan, Metal, DX12, and OpenGL, enabling the GPU-accelerated rendering that Horizon relies on.
- alacritty_terminal: The terminal emulation layer that underpins the actual terminal behavior and rendering, leveraging a battle-tested terminal engine for reliability and speed.
- Catppuccin Mocha: The dark color palette providing a visually cohesive and accessible aesthetic for the terminal panels and UI elements.
- The combination of these technologies emphasizes speed, cross-platform compatibility, and a polished user experience that scales with complex workflows.
- Community, Contributions, and Documentation
- Horizon invites collaboration and provides clear guidance for developers who want to contribute:
- AGENTS.md outlines the development setup, architectural considerations, coding standards, and CI requirements, helping new contributors get oriented quickly.
- docs/release-flow.md describes release procedures, ensuring a consistent and reliable release process.
- docs/testing contains manual smoke-test plans, including a workspace close smoke test plan, to help verify functionality before releases.
- Quality checks are codified in repository commands, such as cargo fmt, cargo test, and cargo clippy, to help maintain code quality, consistency, and stability across the project.
- The project emphasizes practical, repeatable testing and a clear path for onboarding contributors, ensuring that improvements are maintainable and aligned with the broader design goals.
- Licensing
- Horizon is released under the MIT License, reflecting an open approach to software distribution. This encourages experimentation, adaptation, and collaboration while providing a permissive framework for developers and users to modify and extend Horizon.
- Imagery and Visual Elements: A Note on Visual Assets
- The Horizon experience is closely tied to its visuals, including the hero banner that communicates the canvas-first philosophy and the demo animation that showcases pan-and-zoom capabilities and workspace organization.
- Visual assets serve not only as decorative elements but as functional cues that help users understand how the canvas works, where panels live, and how workspaces can be composed and navigated.
- Summary: A Vision for Terminal Workflows
- Horizon redefines how a traditional terminal environment is organized by introducing an expansive, interactive canvas that merges terminal panels with spatial organization. It combines high-speed GPU rendering, a robust terminal engine, and first-class integrations with AI agents to support modern development, debugging, and operations workflows.
- The system’s flexibility—through color-coded workspaces, auto-arranged layouts, and a live settings editor—provides a scalable framework for both individual developers and teams who want to coordinate complex tasks without losing context.
- With practical features such as a built-in Git status panel, remote-host discovery, and an intuitive set of keyboard and mouse interactions, Horizon offers a cohesive and powerful workspace that makes terminal work feel more like a visual, dynamic process rather than a sequence of isolated tasks.
- The ongoing emphasis on persistence and continuity ensures workspaces, panels, and histories follow you across sessions, enabling you to return to an exact state tomorrow as if you never paused today.
- Visual References and Accessibility
- Image references from the input are included to ground this description in the actual visuals of the Horizon project:
- Image: Horizon banner (assets/hero-banner.svg) at the top to illustrate the canvas concept.
- Image: Horizon demo (assets/demo.gif) to convey interactive panning, workspace switching, and panel organization.
- Closing Thoughts
- Horizon is a bold rethinking of how developers, operators, and AI-assisted workflows interact with terminal sessions. By combining an infinite canvas with structured workspaces, real-time configuration, and intelligent integrations, Horizon aims to streamline complex tasks, improve situational awareness, and reduce the cognitive load associated with juggling multiple terminals and tools.
- If you’re looking for a terminal environment that grows with your projects rather than constraining them, Horizon presents an adaptable platform where sessions, tools, and collaborators can coexist in a single, navigable expanse.
Enjoying this project?
Discover more amazing open-source projects on TechLogHub. We curate the best developer tools and projects.
Repository:https://github.com/peters/horizon
GitHub - peters/horizon: Horizon
Horizon is an open-source GPU-accelerated terminal board that reimagines how you work with multiple terminals by presenting them on an infinite 2D canvas....
github - peters/horizon