Pebrel: a GPU-accelerated terminal built around AI CLI sessions

The problem Pebrel picks: AI CLI sessions scattered across a plain terminal

Claude Code, Codex and similar command-line agents run fine in any terminal. What they do not do is tell the terminal anything about themselves. A long agent run looks like a silent pane, and when it finishes you scroll back through output to find the answer. Pebrel's premise is that the emulator should know which CLI is running in which pane, show an activity state, and route notifications back to the pane that produced them. The README describes icons and activity states for recognized CLIs, and says supported hook events provide more precise progress and attention signals. That is the whole product thesis: a terminal that is aware of the agent inside it.

The target user is a developer on Windows who already runs these tools and wants remote hosts, local files and agent sessions in one window instead of three. Split panes, saved workspace layouts and per-pane working directories are the supporting cast. The repository's topic list names conpty, powershell and ssh-client alongside claude-code and codex, which matches the README's framing.

How Pebrel is put together: a Rust workspace, GPUI rendering, and a Lua config layer

The Cargo.toml shows a workspace with nine members: nebula_app, nebula_terminal, nebula_config, nebula_config_derive, nebula-completions, nebula_hook, nebula_gpui, nebula_settings and nebula_split. The names map onto the feature list. nebula_terminal holds the VT side, nebula_split the pane layout, nebula_hook the CLI hook integration, and nebula_gpui the rendering layer. The binary is still called pebrel.exe even though the crate names keep the Nebula prefix, which tells you the rename was applied to the product and the packaging rather than to every internal path.

The release profile is deliberately tuned. The workspace sets opt-level = "s" as the default and pins resvg, rustybuzz, taffy, ttf-parser, smol, gpui, gpui-component, nebula_terminal and nebula to opt-level = 3. The comment in the file explains the reasoning: cold code such as the protocol stack, serialization, CLI and SSH dependencies compiles for size, while rendering, shaping, layout and VT parsing are pinned back to O3. It also states a package size budget of under 30 MB for the installer. That is a real constraint, not a slogan, and it is why thin LTO with codegen-units = 1 is used instead of fat LTO.

The dev profile takes the opposite tack: external dependencies compile at opt-level 2, with the same shaping and layout crates pinned to 3, because at opt-level 0 window dragging and continuous input show latency that the release build does not have. If you build from source, expect a debug binary that still carries real terminal load.

Configuration is Lua, with TOML still accepted. The README states the generated Lua configuration uses require 'pebrel' and pebrel.config_builder(), and that validation and live reload are supported.

Installing Pebrel on Windows and running a first AI session

The README points to the latest release page and lists packages per system. Windows 10 1809+ and 11 get an installer .exe and a portable .zip for x64. Linux Preview needs glibc 2.35+ and ships .AppImage, .deb and portable .tar.gz. macOS Preview targets deployment 14+ with .dmg files for Apple Silicon and Intel. Package names follow Pebrel-v<version>-<system>-<architecture>, with Linux and macOS builds marked -preview before the extension.

On Windows, run the installer or extract the ZIP and launch pebrel.exe, keeping the bundled directories together. Then generate a configuration and validate it:

pebrel config init --language en-US
pebrel config check

The first command writes a Lua configuration using require 'pebrel' and pebrel.config_builder(); the second validates it. If you already have a Nebula installation, INSTALL.md is where the README sends you for platform requirements and the upgrade path.

After that, the practical first use is opening a split, starting Claude Code in one pane and a shell in the other. The README's screenshots show exactly this arrangement with OpenCode, Claude Code and Codex side by side. Notifications follow their source pane, and clicking one returns you to that terminal. Captured Claude Code and Codex answers open in a reader with Markdown, formulas, source text and local image previews. On Windows, automatic local AI-hook setup runs during installation; on Linux and macOS it does not.

Where Pebrel stops: hooks, image protocols, and Preview platforms

The AI integration is conditional, and the README is honest about it. Supported hook events give the precise progress and attention signals; without a hook, the terminal falls back to recognizing the CLI by name. Session restoration after the process exits requires a supported CLI and a usable session identity. On WSL and Linux, Codex session metadata can supply an ID when its hook has not reported one, which implies that on Windows the hook is the expected path.

Image handling has the same shape. Clipboard images are saved as PNG files and their paths are inserted into local, WSL or SSH sessions. Inline terminal images require the CLI to emit the supported OSC 1337 protocol, and image attachment previews depend on the CLI itself. So the feature is only as good as the agent on the other end.

Platform coverage is the second boundary. Windows gets tray residency, the global quick-terminal hotkey, automatic local AI-hook setup and automatic update installation. The README states these integrations are not yet available on Linux or macOS. Those builds are also labelled Preview, and the README notes that native macOS CI runs on macOS 15, so the deployment target alone does not establish validation on every older OS version. Ad-hoc-signed macOS builds may require Open Anyway in System Settings on first launch.

Background residency is Windows-only too, and it is narrower than it sounds: it keeps running sessions alive when you close the window, but restoring a conversation after the process exits is a separate feature with its own requirements.

What Pebrel is not: the case for an established terminal

If you want a terminal that has been on Linux for years, with a plugin ecosystem and a configuration format you already know, Pebrel is the wrong tool. Windows Terminal and WezTerm both run on more platforms with fewer Preview labels, and neither asks you to trust a hook integration to know what your agent is doing. WezTerm's approach is the clearest contrast: it is configured in Lua too, but it is a multiplexer-first terminal that runs on its own terms across platforms, whereas Pebrel's differentiator is the AI session layer and the Windows-native integrations around it. If you do not run Claude Code or Codex, that layer is dead weight and you are paying for it in a GPL-3.0 codebase.

There is also a licensing consideration. Pebrel is GPL-3.0. If you embed it, redistribute a modified build, or ship it inside a product, the copyleft terms apply to the combined work. Reading that as legal advice would be a mistake; the point is simply that the licence is in the repository root and worth reading before you build on it rather than after.

The maintenance picture is current. The repository is not archived, and the most recent push recorded for it is 2026-09-10. Releases v1.6.0 on 2026-09-07, v1.5.0 on 2026-09-01 and v1.4.1 on 2026-08-30 show a steady cadence over that window. Note that the release titles mix names: v1.6.0 is labelled Pebrel 1.6.0 while v1.5.0 and v1.4.1 are still labelled Nebula Terminal, which is consistent with a rename in progress. The homepage field points at a releases URL under the nebula path rather than pebrel, another sign of the transition.

Upgrade cost and the toolchain you are signing up for

Building from source is not casual. The workspace requires Rust edition 2024 and rust-version 1.97.1, and rust-toolchain.toml exists to pin that. The workspace dependencies include mlua 0.11.4 with the lua54, vendored, serialize and send features, toml 0.9.11, toml_edit 0.24.0 and serde_path_to_error 0.1.20. The Cargo.toml comment notes that gpui 1.16.1 moved its platform entry point into a separate crate that must use the same Git URL and rev as gpui itself, or Cargo will treat them as different packages. That is the kind of detail that turns a first build into an afternoon.

The release profile also warns that changing it requires re-running scripts/tests/package-release.tests.ps1. If you fork and start tuning opt-level values, that script is the check the maintainers expect you to run.

For users rather than builders, the upgrade cost is lower but uneven. Windows has automatic update installation. Linux and macOS users install by hand from the release page each time. Configuration migration is the other axis: Lua is the documented path, with TOML still supported, so an existing TOML configuration does not have to be rewritten immediately.

Editorial conclusion

Adopt Pebrel if you run Claude Code or Codex on Windows and want those sessions, SSH hosts and file transfers inside one native window; the Windows package is the only one with tray residency, the quick-terminal hotkey, automatic hook setup and automatic updates. Skip it if you need a mature Linux or macOS terminal, or if your workflow depends on image protocols and hooks you cannot control. Before installing, open the Cargo.toml workspace to confirm the Rust 1.97.1 and edition 2024 toolchain, and read INSTALL.md for the upgrade path from an existing Nebula installation.

Frequently asked questions

Official sources

1. Kuddev/pebrel on GitHub
2. License: GPL-3.0
3. Project website
4. README
5. Releases