px0 is an MIT-licensed, Go-based review workbench and speed-first IDE that runs in the browser, built for engineers whose bottleneck has shifted from writing code to reviewing, navigating, and verifying the code that AI agents produce.

What it is

px0 is a developer tool written in Go that sits in the IDEs and code editors category, but it is deliberately not a full editing suite. It pairs a small native Go daemon with a browser-rendered UI, and it is designed around the review loop: reading diffs, tracing changes across a repository, leaving inline comments, and handing work off to an AI coding harness. The README frames the premise directly — as agents author more code from the terminal, productivity is constrained by how fast a change can be reviewed and verified rather than by typing speed.

The concrete problem it solves is weight. px0 positions itself as the replacement for heavy, multi-gigabyte editing suites, and the benchmarks compare it against VS Code specifically: the Go server uses roughly 20–30 MB resident memory, the active browser tab 80–150 MB, for a combined footprint of about 100–180 MB, against roughly 1,440 MB for Electron IDEs that bundle their own Chromium and Node runtimes. Alongside that, it replaces the browser-tab-and-terminal shuffle for Git work by putting merge-base diffs, commit browsing, staging, committing, pushing, and squash-and-merge inside the same console.

Key capabilities

• Scoped merge-base diff inspection with inline comment drafting, commit diff browsing, and stage, commit, or push from the browser.
• One-click agentic rebase for conflict resolution, plus squash and merge.
• Multi-turn agent threads anchored to code ranges (Alt+T), with live tool execution streamed over Server-Sent Events and batch inline edits queued across files (Alt+E).
• Dispatch to local AI coding harnesses including Claude Code, Cursor Agent, Antigravity, OpenCode, Codex, Aider, and Goose.
• Unpushed commit review, reading the commits a branch is ahead of its tracking branch by one file diff at a time before pushing.
• In-place quick editing and saving in the browser (Cmd/Ctrl+E, Cmd/Ctrl+S) with unsaved-change protection.
• Millisecond navigation through fuzzy file search (Cmd/Ctrl+P), symbol outline (Cmd/Ctrl+Shift+O), and workspace regex search (Cmd/Ctrl+Shift+F).

Who uses it and how

• Teams working on remote servers, VMs, or containers, where the daemon is bound with px0 -host 0.0.0.0 on the same port and the remote host pays only the ~20–30 MB server cost.
• Reviewers handling agent-authored branches, who walk unpushed commits file by file before pushing rather than opening a full editor.
• Engineers searching very large codebases, using the benchmark corpus (~3 GB spanning Linux, Kubernetes, and TypeScript) as the reference scale.
• Teams already using terminal-based AI harnesses, who dispatch prompts from anchored code ranges to Claude Code, Codex, Aider, or similar tools.
• Security-conscious operators exposing the workbench over Tailscale, WireGuard, a reverse proxy, or Cloudflare Tunnel, with workspace-confined file access, path traversal protection, and DNS rebinding checks.

Getting started

px0 is distributed as source: clone https://github.com/px0-ai/px0.git, run make test and make build, or use go run . -dev . for live frontend development that serves web/ assets from disk. Launch the resulting binary from the workspace directory and open the address reachable from your local machine; it is saved in $XDG_STATE_HOME/px0/workbench.json (or ~/.px0/workbench.json).

How it compares

Among the tools named in the facts, px0's nearest point of reference is VS Code, which its benchmarks treat as the Electron-based baseline it is trying to undercut on memory. It is not a drop-in editor replacement so much as a lighter, browser-served review console that coexists with AI harnesses such as Claude Code, Codex, Aider, and Goose, which it dispatches to rather than subsumes.

When to use it — and when not to

A self-hoster must run and maintain the Go daemon on a remote host and take responsibility for network exposure, since the README states plainly that anyone who can reach the address can edit files in the workspace and browse and open any directory px0 can read — so it belongs on trusted networks only. Teams that need a full multi-gigabyte editing suite with every language tooling integration, or that require multi-user authentication and per-user access control, should not pick it. Prospective adopters should also weigh the project's maturity signals: 151 open issues against 1,895 stars, and a README whose excerpt is partly truncated, which suggests documentation is still catching up with the feature set.

git clone https://github.com/px0-ai/px0.git
cd px0

# Run tests
make test

# Live frontend development (serves web/ assets directly from disk)
go run . -dev .

# Build binary
make build

# Clone the benchmark corpus (~3 GB: Linux, Kubernetes, TypeScript, etc.)
./benchmark.sh --clone

# Run benchmarks across the corpus
./benchmark.sh

# Compare px0 directly against VS Code on the current workspace
./benchmark.sh --vscode .

# Profile memory lifecycle (index, search, idle memory release)
./benchmark.sh --memory bench-repos/linux