px0 is an IDE built for reviewing AI-generated code, optimized for speed. It boots in under 1 millisecond and uses approximately 20 MB of RAM, turning your browser into a zero-latency console with native Git and GitHub integrations, instant search across massive codebases, and seamless handoff to local AI coding harnesses.

Can px0 be used to inspect code on remote servers and cloud VMs?

Yes. px0 is remote-first. You can run `px0 -host 0.0.0.0` on any remote server, VM, CI runner, or container and browse the codebase directly from your local web browser over HTTP or TLS, without configuring SSH keys, setting up port-forwarding tunnels, or running heavy server daemons.

Why use px0 instead of a heavy editor like VS Code?

Code increasingly arrives from the terminal via AI coding agents, compilers, or remote test runners. Developers spend most of their time in verification, audit, and navigation. Full desktop IDEs take seconds to boot and consume 1.4+ GB of RAM just to inspect files. px0 starts in under 1 ms with ~20 MB RAM, providing zero-latency code reading and delegated agent editing without editor bloat.

Does px0 require language servers to work?

No. Language servers are completely optional. px0 automatically detects servers like gopls, rust-analyzer, or clangd on your PATH if present, but falls back instantly to a built-in regex-based outline and fuzzy search if no server is installed.

How does px0 handle large repositories?

px0 uses windowed syntax highlighting and virtual DOM rendering (only rendering visible rows on screen), so opening a 400,000-line file costs the same as a 10-line file. It fuzzy-finds across the Linux kernel (95,710 files) in 6 ms.

How do I install px0?

Run `curl -fsSL https://px0.ai/install.sh | sh` on macOS, Linux, or BSD. Prebuilt binaries for 15 OS and architecture targets are also available on GitHub Releases.

How do I avoid sudo prompts when installing or updating px0?

If px0 was previously installed with sudo, remove the active root-owned binary and reinstall cleanly to user space (~/.local/bin) by running: `sudo rm -f "$(which px0)" && curl -fsSL https://px0.ai/install.sh | sh`. All future updates will then run in user space with zero sudo requirements.

Does px0 send code or project data to the cloud?

No. px0 runs strictly locally and never transmits your code, file paths, symbol names, or search queries.

Pairing with AI Coding Agents

When working with autonomous coding agents such as Claude Code, Google Antigravity, Gemini CLI, Cursor Agent, OpenCode, Codex, Aider, or Goose, code modifications arrive rapidly across multiple files. Running a 1.5 GB Electron IDE to supervise edits wastes gigabytes of system memory and risks typing conflicts.

Built specifically for reviewing AI-generated code, px0 pairs with autonomous coding agents in three distinct ways:

Multi-Turn Agent Threads (Alt+T): Conduct persistent, multi-turn conversations anchored to code selections or workspace concepts. Inspect tool steps live and follow up across turns directly in the right sidebar Threads pane.
Integrated In-App Agent Dispatch (Alt+E): Select code in px0, stage single or batch comments, and dispatch them directly to your installed harness with automatic reloading and live streaming.
Terminal Supervision (Sidecar Mode): Run your agent in your terminal or tmux pane while px0 serves as a lightweight, read-first review station with sub-millisecond Git synchronization.

Mode 1: Multi-Turn Agent Threads

Threads provide an interactive, conversational loop directly beside your code:

Open your workspace with px0 .
Select any code block and press Alt+T (Option+T on macOS), or click the thread icon beside any line number.
The Threads pane in the right inspector opens, anchored to your selection.
Enter your question or prompt (e.g. “Explain how this error path is handled and draft a safer variant”).
Watch live as the harness streams its reply and collapsible tool steps (Read handler.go, Edit types.go).
Follow up seamlessly with subsequent messages: native session harnesses (claude, agy, gemini, cursor-agent) resume their existing sessions without re-sending full history, saving API tokens.

For a full walkthrough of threads, see the Agent Threads & Multi-Turn Conversations guide.

Mode 2: Integrated In-App Agent Dispatch

px0 can directly invoke your installed coding harnesses for focused edits:

Highlight the code you want modified in either the code viewport or git diff view.
Press Alt+E (or Option+E on macOS), or right-click the selection.
Pick your desired harness and model from the dropdown.
Enter your instruction and press Enter to stage a comment (for batching) or Ctrl+Enter (Cmd+Enter on macOS) to Apply now.
When the edit finishes, px0 automatically reloads touched documents and updates git status gutters.
The edit is preserved as an inline or batch thread in the Threads list for future reference and follow-up queries.

For a comprehensive walkthrough of the in-app agent workflow, consult the Editing with Coding Agents guide.

Mode 3: External Terminal Supervision (Sidecar Mode)

If you prefer driving complex, multi-step agent conversations directly inside your terminal, keep your active terminal pane dedicated to the agent prompt while running px0 alongside it.

Option A: Run in a Separate Terminal Split or Tmux Pane (Recommended)

Open a new terminal tab or tmux pane and launch px0 on your project:

px0 /path/to/project

Your browser opens to http://127.0.0.1:7777. You can stop it at any time with Ctrl+C.

Option B: Run in Headless Background Mode

If you prefer working in a single terminal session, launch px0 in the background with &:

px0 -no-open /path/to/project &

This returns your shell prompt immediately while px0 serves the web UI in the background at http://127.0.0.1:7777.

Stopping a Background px0 Instance

To bring px0 back into the foreground and terminate it:

View active background jobs:

jobs
# [1]+ Running    px0 -no-open /path/to/project &

Bring it to the foreground:
```
fg %1
```
Press Ctrl+C to cleanly stop the server.

Alternatively, terminate it directly by process name:

killall px0

Refreshing After External Agent Edits

When an external terminal agent finishes applying changes to disk:

Click the Reindex / Reload button (↻) at the top of the file tree in the px0 web interface, or reload your browser.
px0 rescans the project tree in a few milliseconds, refreshes git status badges (M, A, D), and updates diff views against HEAD.

(Note: If you dispatched the edit through px0’s in-app composer using Alt+E or a Thread, reloading occurs automatically when the agent completes.)

Benefits of px0 for Agent Workflows

Optimized for Reads: No heavy editor or accidental keystrokes overwriting agent work in progress.
Zero Watcher Overhead: Without recursive inotify or fsevents watching hundreds of thousands of files, your machine stays cool and quiet.
Chroma Syntax-Highlighted Diffs: Press Ctrl+D (or Cmd+D) to toggle side-by-side or unified diffs with full language syntax coloring across modified lines.
Diff View Selection: Select lines directly inside diff view to send targeted refinements back to your agent or start a thread.
Low CPU & Memory: px0 uses strictly ~20-30 MB of host resident memory (~100-180 MB total including the browser tab) and sub-1% CPU, reserving resources for your agent and compiler.