Pi GPUI

A fast, lightweight native desktop GUI for the pi coding agent, built in Rust with GPUI.

Source repo
bytesbay/pi-gpui
Stars
★ 184
Last updated
3d ago
License
MIT
Primary language
Rust

At a glance

Works with
Portable with changes
You'll need
pi 1.4 or newer (pi 1.x)macOS 13+ on Apple silicon or Linux with glibc 2.35+ and a Vulkan driverRust 1.90 (build from source only)Shell / CLINetwork accessLocal filesystem
Typical use
Developers who already drive pi from the terminal and want a faster, lower-memory graphical front end without changing their models or extensions.
Main limitation
Supports only macOS 13+ on Apple silicon and Linux; Windows is explicitly unsupported.
Website
pi-gpui.dev ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-11-18latest release v0.2.8 (2026-11-17)

What does this agent do, and when should you use it?

Pi GPUI is a native graphical front end for the pi coding agent, written in Rust on GPUI, the UI framework behind Zed, with no Electron or webview. Rather than reimplementing the agent, it drives the pi you already have over RPC, so the same models, extensions, skills and sessions you use in the terminal carry over. The interface offers a project and session sidebar, Zed-style dockable panels, a session tree, inline extension questions, a context ring and visible compaction, plus a plugin system that can draw live views inside tool calls. It measures about 16 MB, opens its window in roughly 0.4 s and idles near 75 MB of memory on an M1 Pro, well below Electron clients for pi. It runs on macOS 13+ (Apple silicon) and Linux (x86_64 and arm64, beta), does not support Windows, and is MIT licensed.

On launch the app locates pi via PI_EXECUTABLE, PATH or your login shell (pi 1.4 or newer, within pi 1.x) and starts a separate pi process per open session, talking to it over RPC, so switching sessions never stops work. The sidebar lists projects and their pi sessions; a floating right panel shows the project's files colored by git status and its git changes, with tabs you can right-click to move sides and edges you can drag to resize. The message field accepts pasted or dropped files and images, saved as paths like in pi's terminal (a pasted image goes to $TMPDIR/pi-clipboard-*.png). It supports slash commands such as /compact, /tree, /fork, /clone, /model, /new, /name, /session, /copy and /export, a session tree with keyboard navigation and branch summaries, forking from any message, and inline answers to extension select/confirm/input/editor questions. Because pi's RPC lacks tree navigation, the app passes its own extensions/pi-gpui-bridge.ts to the pi processes it starts, installing nothing. It can also take over a terminal session through the /gpui command from npm:pi-gpui or a pi-gpui://open?workspace=…&session=… link, and plugins in any language can add buttons, keybindings, status, tools and live views inside tool calls.

  1. Developers who already drive pi from the terminal and want a faster, lower-memory graphical front end without changing their models or extensions.
  2. People running coding agents across several projects in parallel, letting each session keep its own pi process while they switch back and forth.
  3. Zed users who want a familiar dock/panel layout, themes and shortcuts while working with pi.
  4. Teams experimenting with alternative approaches by forking from any point in a conversation's session tree.
  5. Plugin authors who want to add custom tools to pi or render live views inside tool calls, as the bundled DOOM example does.
  6. Anyone who starts a session in the terminal and wants to continue it in the app via /gpui or a pi-gpui:// deep link.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • brew install --cask bytesbay/tap/pi-gpui
  • curl -fsSL https://pi-gpui.dev/install.sh | sh
Config files
~/.local/pi-gpui.app ~/.local/bin/pi-gpui Support/pi-gpui/settings.json ~/.config/pi-gpui/settings.json
Install notes cover
macOS · Linux

How do you install or deploy this agent?

On macOS (Apple silicon, macOS 13 or newer) install with Homebrew:

brew install --cask bytesbay/tap/pi-gpui

Or download Pi-GPUI-*.zip from Releases and move it to Applications; releases are signed with a Developer ID certificate and notarized by Apple.

On Linux (x86_64 and arm64, beta) run the install script:

curl -fsSL https://pi-gpui.dev/install.sh | sh

It places the app in ~/.local/pi-gpui.app, links ~/.local/bin/pi-gpui and adds a launcher entry, with no root needed; you can also unpack pi-gpui-*-linux-*.tar.gz yourself. Linux needs glibc 2.35 or newer (Ubuntu 22.04, Debian 12, Fedora 36) and a Vulkan driver, and runs on X11 and Wayland. Both systems need pi 1.4 or newer within pi 1.x installed and findable via PI_EXECUTABLE, PATH or the login shell.

To hand a terminal session to the app, install the pi extension:

pi install npm:pi-gpui

To build from source:

cargo run [-- /path/to/project]
script/bundle.sh        # macOS: target/release/Pi GPUI.app
script/bundle-linux.sh  # Linux: target/release/pi-gpui.app and the release tarball

How do you use this agent?

After launch the app finds pi on its own; use ⌘O to add a project, ⌘N for a new session, ⌘1…⌘9 to switch among open session tabs, ⌘⇧T for the session tree, ⌘⇧M for model and thinking level, ⌘⇧C to compact, and ⌘B / ⌘R to toggle the left and right panels. Type / in the message field for the command menu, ↩ to send, ⇧↩ for a new line, send while pi is working to steer it, and Esc to stop. On Linux ⌘ becomes Ctrl and ⌥ becomes Alt, except compact is Ctrl+Alt+C. You can also open a project or a deep link directly:

open "pi-gpui://open?workspace=/path/to/project&session=/path/to/session.jsonl"
pi-gpui /path/to/project

Settings live in ~/Library/Application Support/pi-gpui/settings.json (on Linux ~/.config/pi-gpui/settings.json) and apply as soon as they are saved:

{
  "theme": "system",
  "ui_font_family": ".SystemUIFont",
  "agent_font_size": 14,
  "buffer_font_family": "JetBrains Mono NL",
  "buffer_font_size": 12,
}

Custom themes are JSON files in the themes folder next to settings.json; six colors are enough, and a Zed theme file dropped there works as is.

What are this agent's strengths and limitations?

Pros
  • Native GPUI rendering with no Electron or webview: about 16 MB on disk, roughly 0.4 s to window and about 75 MB idle on an M1 Pro, with the benchmark method and script published.
  • Does not reimplement the agent: it reuses your installed pi over RPC, so models, extensions, skills and sessions match the terminal, and each open session runs its own pi so switching never stops work.
  • Session-tree navigation missing from pi's RPC is provided by the app's own extensions/pi-gpui-bridge.ts passed to the pi processes it starts, installing nothing into your environment.
  • Plugins in any language can add buttons, keybindings, status, tools for pi and live views inside tool calls, as the DOOM example demonstrates.
  • Fork from any message, answer extension questions inline, take over terminal sessions with /gpui or pi-gpui:// deep links, and rely on signed, notarized, self-updating releases.
Limitations
  • Supports only macOS 13+ on Apple silicon and Linux; Windows is explicitly unsupported.
  • The Linux build is beta, tested only on Ubuntu 24.04 arm64 in a VM (GNOME on X11 and Wayland under Weston); other desktops, real GPUs and the x86_64 build are untried.
  • Hard dependency on a local pi 1.4–1.x install, with compatibility tracking releases; pi minors newer than the tested one run but are marked untested.
  • Documented limits: pi running in a terminal on the same session is not detected, and extension setStatus, setWidget and setTitle output is not shown yet.
  • Building from source requires pinned Rust 1.90 plus Xcode on macOS or Linux dev libraries, and copies not installed as pi-gpui.app do not self-update.

How does this agent compare with similar options?

The README compares Pi GPUI with Electron clients for pi: on an M1 Pro with no projects open, those take 0.5 to 1.1 s and 190 to 430 MB, against about 0.4 s and 75 MB here. It also complements the terminal pi: the /gpui command moves a session from the terminal into the app, though a pi still running that session in a terminal is not detected.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
Pi GPUI This agent 56 · Major gaps — ★ 184 3d ago Rust —
Waku Coding Agent Desktop 50 · Major gaps Desktop appFree + model costs ★ 1.6k 1mo ago Rust Codex · Claude Code
Hermes Agent CN Desktop 55 · Major gaps Desktop appFree + model costs ★ 1.9k 1d ago TypeScript —
DeepTide - AI Coding Agent by DeepSeek 55 · Major gaps CLIFree + model costs ★ 1.1k 3mo ago Rust OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
56/ 100 5-point scale 2.8 / 5
Trust 14/29
Reliability 8/14
Adaptability 10/18
Convention 13/18
Effectiveness 7/13
Verifiability 4/8
Why each dimension lost points
Trust14 / 29 · 2.4/5

least_privilege: Linux install uses curl|sh and the /gpui plugin spawns /bin/sh polling then exec, widening the permission surface — 1. user_confirmation: updates and pi upgrades require a click, session deletion goes to Trash — 2. data_flow_transparency: README states where sessions/settings live but does not systematically describe outbound data paths — 1. sensitive_data_handling: pasted images written to $TMPDIR and session handoff, no cleanup or encryption noted — 1. dependency_security: Cargo deps are recent but no audit/lockfile discussion — 1. external_effects: update, pi upgrade and link opening have explicit triggers — 2. rollback: session deletion to Trash and restart-to-update, but no version rollback — 2. source_attribution: README credits pi, GPUI, fonts — 2.

Reliability8 / 14 · 2.9/5

self_consistency: README, Cargo.toml, CI and source broadly agree — 2. dependency_availability: versions present but no lock/availability verification — 1. failure_messages: source has multiple eprintln and user notices — 2.

Adaptability10 / 18 · 2.8/5

audience_and_scenarios: desktop GUI for pi users, clear scenario — 2. capability_boundaries: Known limits and Linux differences documented — 2. trigger_precision: /gpui and pi-gpui:// triggers clear but version detection is brittle — 1. environment_fit: macOS/Linux adaptation well described — 2.

Convention13 / 18 · 3.6/5

information_architecture: README well structured — 2. install_notes: detailed install incl. signing and deps — 3. naming_stability: legacy name migration exists but naming history is mixed — 2. examples_and_faq: example plugin and demo, limited FAQ — 2. known_limitations: Known limits and Linux notes present — 2. license: MIT explicit — 3. versioning_changelog: version and Conventional Commits but no standalone CHANGELOG — 2. maintenance_responsibility: publisher unverified, ownership unclear — 1.

Effectiveness7 / 13 · 2.7/5

output_usability: GUI output usability well described — 2. marginal_value: performance advantage over Electron clients — 2. cost_benefit: performance figures are author self-measured, not independently verified — 1.

Verifiability4 / 8 · 2.5/5

claim_traceability: performance data links method and script — 2. cross_source_corroboration: single source, no third-party corroboration — 1. fact_inference_separation: README distinguishes real run from scripted demo — 2.

Risks and how to mitigate them
  • Linux install runs a remote script via curl|sh; review site/install.sh before executing.
  • The /gpui plugin spawns /bin/sh to poll the process then exec the link; note its process and permission behavior.
  • Performance figures are author self-measured and not independently reproduced; do not infer reliability from them.
  • Publisher identity is unverified; maintenance responsibility and update path should be independently confirmed.
Evidence confidence: Low Reviewed Nov 20, 2026 Reviewed revision a8d40e30c4ea
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/pi-gpui.svg)](https://followagents.com/en/agents/pi-gpui)
<a href="https://followagents.com/en/agents/pi-gpui"><img src="https://followagents.com/badge/pi-gpui.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.2.8 Pi GPUI 0.2.8
    Release notes excerpt
    Full Changelog: https://github.com/bytesbay/pi-gpui/compare/v0.2.7...v0.2.8
    View on GitHub ↗
  2. v0.2.7 Pi GPUI 0.2.7
    Release notes excerpt
    Full Changelog: https://github.com/bytesbay/pi-gpui/compare/v0.2.6...v0.2.7
    View on GitHub ↗
  3. v0.2.5 Pi GPUI 0.2.5
    Release notes excerpt
    Full Changelog: https://github.com/bytesbay/pi-gpui/compare/v0.2.4...v0.2.5
    View on GitHub ↗

FAQ

Do I have to pay for it, or bring my own API keys?
The app itself is free and MIT licensed. It drives your existing pi install, so model access and provider keys are whatever your pi configuration already uses; the app does not supply or manage them.
Does it modify my pi setup?
It does not rewrite pi. It talks to your local pi over RPC, keeps model and thinking level per session instead of changing pi's defaults, and only runs pi's own pi update when you click to update pi or its extensions.
Is the Linux build usable today?
It is beta: the same code with its own window frame, no menu bar, Ctrl-based shortcuts and config under ~/.config/pi-gpui, requiring glibc 2.35+ and a Vulkan driver. It has only been tested on Ubuntu 24.04 arm64 in a VM, and feedback is collected in issue #5.
Can I move a session I started in the terminal into the app?
Yes. After pi install npm:pi-gpui, run /gpui inside pi; it closes that pi and opens the same session in Pi GPUI. Other tools can use a pi-gpui://open?workspace=…&session=… link, or on Linux pass the link or a folder to pi-gpui.
What is known to be missing?
A pi running in a terminal on the same session is not detected, and extension status lines, widgets and window titles (setStatus, setWidget, setTitle) are not shown yet; select, confirm, input and editor questions do work.
Is Pi GPUI open source?
Yes. The source code is on GitHub (bytesbay/pi-gpui) under the MIT licence.
Is Pi GPUI safe to use?
FollowAgents' FARS review (Nov 20, 2026) scored Pi GPUI 14/29 on trust and safety. None of the eight safety controls the review checks for was missing outright.
Is Pi GPUI still maintained?
Yes. The latest commit on GitHub is from 2026-11-18, within the last 30 days. The latest release is v0.2.8 (2026-11-17).
Who makes Pi GPUI?
Pi GPUI is published on GitHub by the account bytesbay. FollowAgents has not verified which person or company is behind that account.
What is Pi GPUI's official website?
The project's GitHub repository lists https://pi-gpui.dev as its website. That link is set by the repository owner; the source code itself is on GitHub (bytesbay/pi-gpui).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts