px0 v0.1.4optimized for readopen source

// when all you want is speed.

Just. Damn.
Fast.

px0 is a fast, ultra-light, remote-first, read-only IDE designed for instant code navigation and review in your browser. It starts in under 1 ms, idles at ~20 MB, and fuzzy-finds across the Linux kernel's 95,710 files in 6 ms.

cold start
<1ms
sub-millisecond instant boot
resident memory
20MB
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
~/workspace/kernel · 95,710 files
127.0.0.1:7777
225 for (;;) {
226 size_t b, c, d;
227
228 if (a) /* Building heap: sift down a */
229 a -= size << shift;
230 else if (n > 3 * size) { /* Sorting: Extract two largest elements */
231 n -= size;
232 do_swap(base, base + n, size, swap_func, priv);
233 shift = do_cmp(base + size, base + 2 * size, cmp_func, priv) <= 0;
234 a = size << shift;
235 n -= size;
236 do_swap(base + a, base + n, size, swap_func, priv);
237 } else { /* Sort complete */
238 break;
239 }
240
241 /*
242 * Sift element at "a" down into heap. This is the
243 * "bottom-up" variant, which significantly reduces
244 * calls to cmp_func(): we find the sift-down path all
245 * the way to the leaves (one compare per level), then
246 * backtrack to find where to insert the target element.
247 *
248 * Because elements tend to sift down close to the leaves,
249 * this uses fewer compares than doing two per level
250 * on the way down. (A bit more than half as many on
251 * average, 3/4 worst-case.)
252 */
253 for (b = a; c = 2*b + size, (d = c + size) < n;)
254 b = do_cmp(base + c, base + d, cmp_func, priv) > 0 ? c : d;
255 if (d == n) /* Special case last leaf with no sibling */
256 b = c;
257
258 /* Now backtrack from "b" to the correct location for "a" */
259 while (b != a && do_cmp(base + a, base + b, cmp_func, priv) >= 0)
260 b = parent(b, lsbit, size);
Search Ctrl Shift FDiff Ctrl D357 linesclangdCPU 0.0% · RAM 55 MB
01/cases

Where px0 fits in best.

When you just need to inspect, navigate, and audit code without booting an editor, waiting on heavy background indexers, or burning gigabytes of RAM.

01agent workflow

Verifying AI Agent Output

Trace symbol references, inspect live git diffs against HEAD, review generated code, and close the tab without leaving your terminal flow.

verifying ai agent output
$ claude code "refactor auth middleware"
 8 files changed · 32 tests passing
$ px0 .
→ browser opens instantly at http://localhost:6789
diff vs HEADCtrl D
symbol jumpF12
context switch0
02zero-ssh remote

Remote & Cloud Server Inspection

Spin up on any remote server, VM, or CI runner and browse the codebase instantly from your local browser: no SSH keys, no port forwarding hassle, and no heavy remote desktop daemons.

remote & cloud server inspection
runner@ci-box:~/repo$ px0 -host 0.0.0.0
px0 v0.1.4 · listening on http://10.0.4.12:6789
local-laptop:~$ open http://dev-runner:6789
 connected directly from local browser
setup requiredzero
port forwardnone
transportHTTP / TLS
03massive repos

Auditing Large Repositories

Read through massive, 50,000+ file codebases on a laptop without background indexers hogging RAM or spinning up fans.

auditing large repositories
$ px0 ~/src/linux
indexed 95,710 files in 370 ms · RSS 20.4 MB
$ # fuzzy search in 6 ms · CPU < 1%
 smooth scrolling across million-line trees
linux kernel95,710 files
index time370 ms
idle memory~20 MB
04companion setup

Sidecar to Terminal Editors

Keep lightweight editors (like Vim, Neovim, or Helix) in the terminal for typing, while using px0 as a high-density, rich graphical inspection and diff console.

sidecar to terminal editors
tmux pane 1: nvim main.go (fast keyboard editing)
tmux pane 2: px0 . (starts in <1 ms)
browser: side-by-side git diffs, Markdown & symbols
 best of both worlds: modal editing + GUI clarity
typing speedterminal
inspectiongraphical
footprint~20 MB
02/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
20 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
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.02git & diff

Status badges & visual diffs

Working-tree status badges (M, A, D, U) in the file tree, dirty ancestor paths, and a changed-only filter. Toggle side-by-side or unified diffs vs HEAD with Ctrl+D.

web/srcA markdown.jsM fuzzy.go
fuzzy.go (diff vs HEAD)Ctrl+D
64- score -= len(p) / 4
64+ score -= len(p) / 8
f.03markdown

Rendered GFM preview

Full GitHub Flavored Markdown and footnotes rendered via goldmark with Chroma-highlighted code fences. Switch preview and source with Alt+M while locking scroll position.

PreviewSourceAltM
# Architecture Deep Dive

Windowed tokenizing with Chroma...

func FuzzyFind()
f.04render

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.05highlight

~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.06lsp · 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.07themes

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.

f.08distribution

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.09memory

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/remote

Remote code. No SSH required.

Spin up on any remote server, cloud instance, or runner in under a millisecond. Inspect and search remote codebases directly in your local browser without configuring SSH keys, forwarding ports through flaky sessions, or installing heavy remote desktop suites.

remote session architecture · zero-friction topology
HTTP / TLS · stateless stream
remote hostcloud / dev box
px0 process1 static Go binary
  • memory~20 MB idle
  • startup< 1 ms
  • scavengerfrees OS memory after 15s
  • accessread-only & sandboxed
your machineany browser
zero-install UIlaptop · tablet · mobile
  • client footprint0 npm / 0 extensions
  • fuzzy findcached in-browser
  • syntax highlightingpre-rendered Chroma
  • diffs vs HEADinstant Myers viewer
common remote workflowsARCHITECTURE.md →
dev box / cloud vm
$ px0 -host 0.0.0.0 -port 7777 ~/work/repo
Instant access over private network / Tailscale
headless ci / test runner
$ px0 -no-open -port 8080 /workspace
Inspect failed build workspaces in any web browser
ephemeral docker / pod
$ docker run -p 7777:7777 -v $(pwd):/src px0:latest
Browse isolated containers without container shells
01NO DAEMON

Zero SSH or heavy client setup

No X11, no remote extension daemon

Remote code editors install gigabytes of node runtimes and background server processes on the remote machine. px0 runs as a single lightweight binary, serving directly over HTTP without requiring you to maintain SSH shell sessions.

02-host 0.0.0.0

Single port over any wire

Tailscale, wireguard, reverse proxy, or tunnel

Pass -host 0.0.0.0 or -port 7777 to bind the web console. Access from any browser on your laptop, iPad, or phone across your private VPN, Tailscale mesh, or Cloudflare Tunnel with pooled gzip compression.

03SANDBOXED

Sandboxed by architecture

Read-only contract & directory traversal guards

Every request is strictly read-only with no write endpoints. safePath rejects directory traversal attempts, host header checks protect against DNS rebinding, and external stdlib jumps require explicit LSP allowlisting.

05/git

Working tree in view. Diff against HEAD.

When AI agents and orchestrators write code, your workflow shifts from typing to verification. px0 tracks git status, bubbles changes through directories, and renders side-by-side split or unified diffs in milliseconds.

git awareness · tree status & diff viewer
HEAD: clean · 4 uncommitted changes
working tree
  • .github
  • docs
  • internal
  • fuzzy.goM
  • git.goA
  • markdown.goA
  • search.go
  • web
  • diff.jsA
  • main.js
  • go.mod
  • README.md
M modifiedA addedD deletedU untrackedR renamed
fuzzy.go+1 −1
CtrlD
HEAD (committed)r.64
61 if dist > 1 {
62 // penalize distance
63 score -= len(p) / 4
64 }
65 return score
Working Tree (modified)M
61 if dist > 1 {
62 // penalize distance
63+ score -= len(p) / 8
64 }
65 return score
Press AltM inside a Markdown file to switch between preview and sourcezero git subprocesses
01DIRTY BUBBLING

Ancestor propagation

Collapsed folders never hide edits

When a deeply nested file changes, every parent directory in the path receives a dirty marker dot. You never miss changes hiding inside collapsed folders.

02Ctrl+D

In-memory Myers diff

Split and unified views vs HEAD

Press Ctrl+D on any file to inspect the diff against HEAD. Additions and deletions render with line gutters and syntax highlighting intact.

03FILTER CHORD

Changed-only filter

Prune 50,000 files to the blast radius

One click filters the entire tree down to only touched paths. Audit an AI agent refactor or local test run without scrolling through clean directories.

06/why

You need to view code. Fast.

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, inspect git diffs, preview rendered docs, and check the architecture.

    Ctrl D diff vs HEAD  Alt M preview
    F12 definition  Shift F12 refs
  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
  • +git awareness, change tree, and split/unified diffs vs HEAD
  • +rendered Markdown preview with live source switch
  • +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 code telemetry or tracking: only anonymous session duration, opt out with -no-telemetry
  • -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, diffing, and verifying code
base memory (rss)~1,440 MB~20 MB70x 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
07/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
  • CtrlDtoggle git diff vs HEAD
  • AltMtoggle Markdown preview / source
  • F12/Ctrlclickgo to definition
  • ShiftF12find all references
  • hovertype signature and docs
  • Alt/Altback, forward through history
palette prefixesCtrl K
  • fileslspsrv→ lspservers.go
  • >commands>diff→ Toggle Git Diff
  • @symbols@score→ fuzzyScore
  • :line:120→ go to line 120
08/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~20 MB
routerHTTP · JSON · pooled gzip
index & gittree, .gitignore, status & diff
searchparallel worker pool
highlight & mdchroma LRU + goldmark GFM
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 →