px0 v0.1.0read-only ide for the ai-agent erasingle static go binarymit

// agents write the code. you verify it.

When all you
want is speed.

px0 is a read-only IDE for the AI-agent era. It turns your browser into an instant verification console for whatever your agents just wrote: symbol-level navigation, full LSP intelligence, and deep search. One binary, zero config. It starts in under 1 ms, idles at ~16 MB, and fuzzy-finds across the Linux kernel's 95,710 files in 6 ms.

Star on GitHubSee the benchmarks ↓
cold start
<1ms
sub-millisecond instant boot
resident memory
16MB
VS Code on the same tree: ~1,440 MB
fuzzy find
6.0ms
linux kernel, 95,710 files
languages
~280
tokenized natively by Chroma
themes
14
one CSS file each
runtime deps
0
no Electron, no Node, no CGO
~/src/px0 · fuzzy.go
127.0.0.1:7777
50 // Collected right-to-left; flip in place.
51 for i, j := 0, len(pos)-1; i < j; i, j = i+1, j-1 {
52 pos[i], pos[j] = pos[j], pos[i]
53 }
54
55 score, prev := 0, -2
56 for k, i := range pos {
57 if i == prev+1 {
58 score += 12 // consecutive run
59 } else if k > 0 {
60 score -= min(i-prev, 12) // gap penalty, bounded
61 }
62 if i >= e.nameStart {
63 score += 14 // basename beats directory noise
64 }
65 if i == 0 || isBoundary(p[i-1]) {
66 score += 16 // start of a path or word segment
67 } else if p[i] >= 'A' && p[i] <= 'Z' && p[i-1] >= 'a' && p[i-1] <= 'z' {
68 score += 14 // camelCase hump
69 }
70 if p[i] == q[k] {
71 score += 4 // exact case
72 }
73 prev = i
74 }
75 // Prefer the shallower, shorter of two otherwise-equal paths.
76 score -= len(p) / 8
77 score -= strings.Count(p, "/") * 2
78 if idx := strings.Index(e.lower[e.nameStart:], q); idx >= 0 {
79 score += 40 // whole query appears verbatim in the basename
80 if idx == 0 {
81 score += 20
82 }
83 }
84 return score, pos, true
85}
Search Ctrl Shift FSymbols Ctrl Shift O156 linesgoplsCPU 0.0% · RAM 16 MBTokyo Night
14 themes
01/bench

Measured, not claimed.

Every number here comes from ./benchmark.sh against shallow clones of seven real repositories. Linux, language servers off, fastest of five requests. Run it on your machine and paste the table anywhere.

resident memory · same workspace · linear scale~90x lighter
px01 go process
16 MB
VS Code15+ processes
1
2
3
4
5
6
~1,440 MB
  1. 1extension host~500 MB
  2. 2language server~350 MB
  3. 3server main~260 MB
  4. 4IPC proxies & utility~190 MB
  5. 5PTY host & terminal~71 MB
  6. 6file watcher~68 MB
real corpus · px0 standalonesorted by files indexed
repolangsourcefilesindexfuzzyfull scanopen bigreopenrsspeak
flaskPython3 MB2351 ms0.8 ms2.3 msn/an/a16 MB18 MB
redisC26 MB1,85513 ms1.0 ms18.2 ms80.8 ms1.2 ms17 MB27 MB
djangoPython74 MB7,01439 ms1.3 ms26.8 ms166.8 ms1.0 ms20 MB29 MB
reactJavaScript63 MB7,17852 ms2.7 ms32.2 ms57.7 ms0.7 ms21 MB28 MB
kubernetesGo370 MB25,926150 ms13.5 ms84.6 ms199.0 ms0.9 ms30 MB44 MB
typescriptTypeScript414 MB66,533566 ms6.2 ms150.3 ms40.9 ms6.5 ms69 MB105 MB
linuxC1,809 MB95,710370 ms6.0 ms451.8 ms26.7 ms0.6 ms55 MB73 MB
full scan searches for a string that matches nothing, so every indexed byte is read. the worst case.open big is the largest source file, cold. file length does not matter: only the visible window is lexed.
linux kernel · rss across a session−37 MB after idle

px0 reclaims memory after 15 s of inactivity, so an open session settles back down.

language server path · goplsserver ready 374 ms, paid once
document outline1.4 ms
go to definition1.5 ms
find all references3.0 ms
hover5.1 ms
px0 memory18 MB
gopls memory122 MB

Servers are separate processes, spawned on the first request for their language and shut down on exit. Without one, px0 falls back to a regex outline instantly.

$ ./benchmark.sh --clone && ./benchmark.shmethodology → BENCHMARKS.md
02/why

Agents write. You verify.

Code now arrives from the terminal, not the keyboard. What is left for you is review, audit, and navigation, and that job needs one thing done exceptionally well: a zero-latency, distraction-free place to read, explore, and verify. Not an editor that takes seconds to boot and gigabytes to idle.

  1. 01terminal

    drives generation

    Agents, harnesses, and orchestrators write the code, run the tests, and move the workflow along.

    agent 14 files changed
✓ 212 tests passed
  2. 02you

    drive verification

    Follow symbol references, read the surrounding context, and check the architecture the change landed in.

    F12 definition  Shift F12 refs
Ctrl Shift F every call site
  3. 03the old ide

    is overkill

    Booting an Electron suite with an extension host and a gigabyte-plus heap just to read agent output.

    1,440 MB rss, 15+ processes
4 - 10 s to index the workspace
read-only is the feature
  • +fuzzy file search, symbols, regex across the tree
  • +go to definition, hover, find references (with an LSP)
  • +jump into stdlib and module-cache sources the server points at
  • +14 themes, word wrap, back and forward history
  • -no write endpoints: the HTTP API reads, searches, and asks language servers
  • -no extension host, no plugin marketplace, no Electron
  • -no telemetry. the one outbound call is a daily release check to GitHub
  • -binds 127.0.0.1 unless you pass -host
where it fits
  • verifying agent output open the worktree, trace the references, close the tab
  • auditing a codebase read a 25,000-file monorepo on a laptop without the fans spinning up
  • remote boxes run on the server, tunnel one port, read in any browser
  • beside your editor keep vim or VS Code for the edits you still type
traditional IDE vs px0side-by-side
dimensiontraditional IDEpx0
built fortyping code character by character, hosting pluginsreading, exploring, and verifying code
base memory (rss)~1,440 MB~16 MB80x to 90x lighter
startup cpu spike35% - 50%< 1%
cold startseveral secondssub-millisecond
process tree15+ Node.js / Electron processes1 static Go binary
workspace indexingmulti-second background churn13 ms for redis, 370 ms for the linux kernel
setupconfig files, plugins, node, npmzero config, zero runtime
03/features

Everything for reading. Nothing else.

The navigation you reach for a hundred times a day, done in milliseconds, in a UI that renders only the lines you can see.

f.01navigate

Fuzzy everything

Files, symbols, and a full-tree regex scan behind three chords. Ranking favours basenames, word boundaries, and camelCase humps, the way fzf feels.

CtrlPgo to file1.3 ms
CtrlShiftOsymbols
CtrlShiftFregex scan26.8 ms
timings: django, 7,014 files
f.02highlight

~280 languages

Native tokenizing through Chroma. The server lexes a 1,000-line window padded with 400 lines of context, never the whole file, and caches rendered HTML under a 512 MB LRU budget.

gorusttypescriptpythoncc++zigluarubyjavakotlinswifthaskellocamlelixirsqlyamltomlnixbashprotobufhcl+ ~258
f.03render

Virtual rows

Opening a 400,000-line file costs the same as a 10-line one. Only the visible window plus 24 rows of overscan is mounted; scrolling recycles rows with a single transform.

400,000 lines in file~60 DOM rows0.015% mounted
f.04lsp · optional

Semantic when you want it

Zero-config detection of servers on your $PATH. Spawned lazily on first request, stopped on exit. Missing or crashed? Instant regex outline instead.

  • gopls
  • rust-analyzer
  • typescript-language-server
  • pyright · ruff
  • clangd
  • zls
  • lua-language-server
  • solargraph
f.05themes

14 built in

Tokyo Night by default, plus Paper, Catppuccin, Dracula, GitHub Dark, Gruvbox, Monokai, Nord, One Dark, Rose Pine, and Solarized. A theme is one CSS file of tokens.

write your own → STYLING.md
f.06distribution

One static binary

HTML, CSS, and JS are embedded with go:embed. No Electron, no Node, no CGO, no system libraries. Copy it to a box and run it.

px0 static, go:embed
├─ index · search · highlight · lsp
├─ web/     html css js, ~74 KB
└─ themes/  14 × css
f.07memory

Gives memory back

After 15 seconds without requests, px0 reclaims memory. A tab left open for the afternoon costs what an idle one should.

peak94 MB
30 s idle57 MB
linux kernel, after five full scans
04/arch

One process. No runtime.

A Go server that owns indexing, search, highlighting, and language servers, talking JSON to a zero-dependency ES module frontend. The speed comes from a pile of small, boring decisions.

browservanilla js
  • virtual rows ~60 nodes
  • fuzzy & tree cache
  • offscreen font measure
  • rAF-throttled paint
px0 · one go process~16 MB
routerHTTP · JSON · pooled gzip
indexpaths + tree, .gitignore aware
searchparallel worker pool
highlightchroma, windowed, LRU
lsp managerlazy spawn, regex fallback
scavengerreclaims memory after 15 s idle
hostyours
  • source tree + .gitignore
  • gopls · clangd · … on first use
  • stdlib & module cache allowlisted
index
walk semaphore
NumCPU × 4
ignore rules
segment · suffix · path, regex last
dir symlinks
skipped, no cycles
startup
listen first, index in background
highlight
hlChunk
1,000 lines
hlContext
400 lines
hlWindowBytes
512 KB
bgLimit
2 MB exact pass
cacheBudget
512 MB LRU
search
fast reject
bytes.Contains on whole file
buffers
reused per worker
case fold
in-place ASCII lower
snipLead
32 runes
frontend
live rows
~60
OVERSCAN
24 rows
paint
requestAnimationFrame
measure
offscreen, sub-pixel ch
fuzzyScore() · weightsO(n) two-pass
query verbatim in basename+40
basename starts with query+20
start of a path or word+16
camelCase hump+14
inside the basename+14
consecutive run+12
exact case+4
gap between hits
−min(gap, 12)
path length
−len / 8
depth
−2 per /

Pass one proves every query rune is present. Pass two walks back from the last hit to pull matches as tight as possible. The same ranking feel as a dynamic program, in a linear scan. ARCHITECTURE.md →

05/keys

Hands stay on the keyboard.

The chords you already know from your editor, plus one palette that switches mode on its first character. Press ? inside px0 for the full sheet.

shortcuts12 bindings
  • CtrlKuniversal palette, quick open
  • CtrlPgo to file
  • CtrlShiftPcommand palette
  • CtrlShiftOgo to symbol in file
  • CtrlShiftFsearch the whole workspace
  • CtrlFfind in active file
  • CtrlGjump to line
  • F12/Ctrlclickgo to definition
  • ShiftF12find all references
  • hovertype signature and docs
  • Ctrlhoverinspect identifier link
  • Alt←/Alt→back, forward through history
palette prefixesCtrl K
  • ∅fileslspsrv→ lspservers.go
  • >commands>wrap→ Toggle Word Wrap
  • @symbols@score→ fuzzyScore
  • :line:120→ go to line 120
06/cli

Point it at a directory. That's the setup.

px0 starts the local viewer, prints the URL, and opens your browser while the index builds in the background. Multiple instances walk forward to the next free port.

~ · zsh
$ px0 ~/src/linux

px0 0.1.0
  workspace:  /home/you/src/linux
  url:        http://127.0.0.1:7777

ctrl-c to stop
✓ indexed 95710 files  370ms
  · language servers: clangd (started on first use)

$ px0 -version
px0 0.1.0 (linux/amd64)

$ px0 -no-open -port 0 ~/src/api | cat
...
[OK] indexed 1855 files  13ms
flagsusage: px0 [flags] [directory]
flagdefaultdoes
-port N7777port to listen on (0 picks an ephemeral free port)
-host H127.0.0.1local address to bind
-no-openfalsedo not launch the browser
-no-lspfalseskip language servers, use the regex outline
-no-colorfalsestrip ANSI escape sequences
-quietfalsesuppress narration, errors still go to stderr
-updatefalsecheck for and install the latest release
-versionfalseprint version and architecture, then exit
07/install

One binary. Pick a way in.

Install, point it at a repository, and read. Language servers are optional and picked up from your $PATH whenever they exist.

a · quick installmacos · linux · bsd

Installs or upgrades to the latest release.

VERSION
pin a release, default latest
INSTALL_DIR
/usr/local/bin or ~/.local/bin
b · prebuilt binary15 targets
darwinamd64arm64
linux386amd64armarm64riscv64
freebsdamd64arm64
openbsdamd64arm64
netbsdamd64
windows386amd64arm64
$ sudo install px0-0.1.0-darwin-arm64 /usr/local/bin/px0
GitHub releases →
c · from sourcego 1.24+
git clone https://github.com/px0-ai/px0.git
cd px0
make build
sudo install px0 /usr/local/bin/

No npm, no node, no CGO, no system libraries. make dist cross-compiles all 15 targets.

optional · language servers for go to definition, hover, referencesclick a command to copy
languageserverinstall
Gogopls
Rustrust-analyzer
TypeScript / JavaScripttypescript-language-server
Pythonpyright or ruff
C / C++clangd
Zigzls
Lualua-language-server
Rubysolargraph

$ px0

Your codebase, open in the time it takes to read this line.

Star on GitHub