pyproc
Real Python in your browser tab.
No server.
CPython 3.14 on WebAssembly with real processes, multi-core parallelism, checkpoint/time-travel, and a computer you can export as a single file. Zero dependencies, no build step. Chromium/Edge.
N GILs, real parallelism
snapshot in, process out
no sockets, no backend
with disk and signature
boot (offline-ready)
This page prints no benchmark headlines. A number on a landing page is a number you owe forever, and that debt steers the product. pyproc pays off when a product can prepare state once, restore it, or shard work across browser processes; single-kernel NumPy remains ordinary WebAssembly BLAS. Measure it on your own machine in Speed Lab.
The same demos, full page
Every demo above runs in the hero console. These pages are the same thing with room to poke at it.
Immortal Python Machine
One Python state across tabs. Close the leader and another tab recovers memory and files locally.
The agent sandbox loop
Prepare a Python environment once, checkpoint, let buggy code corrupt it, restore in milliseconds (no re-run), then branch two approaches from the same state. The agent retry loop, in the tab.
The Python Machine
A computer that never turns off: close the tab, it hibernates as a few MB; reopen, it resumes. Export it as one signed .pymachine file and open it with a trusted key.
Server Dev
FastAPI, SQLite, editable app.py, and a live iframe preview, all served by Python through a Service Worker virtual origin in this tab.
Speed Lab
Run NumPy matrix multiply once on one Python worker, then shard the same job across 4 workers through the public PyProc API. Measure it on your own machine; single-kernel BLAS is a separate axis.
Terminal
A real REPL: input() genuinely blocks (WebAssembly JSPI), and %undo time-travels the heap to before your last statement.
Process OS
Fork workers from a memory snapshot and run on real CPU cores in parallel. First visit reloads once to unlock SharedArrayBuffer.
Basics
Boot CPython, run code, load numpy. The smallest possible start.
The OS primitives underneath
Processes and fork
Web Worker = process. Boot once, snapshot the heap, fork N interpreters: N GILs, N cores, kill/interrupt/respawn lifecycle.
Checkpoint and time-travel
Full-hash heap checkpoints at execution boundaries. Restore writes only the changed pages instead of re-running, guarded against silent corruption by a mutation counter.
Portable machine images
The whole running computer in one .pymachine file: SHA-256 integrity, explicit trust gate, and a determinism check before any delta is applied.
uv-grade environments
bootEnv restores a bare-heap snapshot and installs wheels from an OPFS cache. runScript runs PEP 723 self-sufficient scripts. freeze() pins it all.
A server on a real URL
The bundled service worker maps fetch("/pyproc/...") to your in-kernel FastAPI app: real URLs, zero sockets, no backend.
Persistent disk and offline
/home/web is a real OPFS-backed disk that survives kernels. Core assets cache so the second boot needs no network at all.
Used by real products
dartlab
Financial-disclosure notebooks over DART and SEC filings. pyproc's in-kernel ASGI server is the live browser-as-server backend: a Python FastAPI app answers fetch("/pyapi/...") with no socket, in production today.
xlpod
A browser spreadsheet that runs real Python inside cell formulas (=PYUDF(...)). Adopting pyproc's Runtime for the interpreter, interrupt-driven cancellation of runaway UDFs, and the value bridge.
A worker that already booted its own Pyodide adopts pyproc with new Runtime(py): no second interpreter, all the capabilities.
Build with pyproc as a library
Product code should consume root exports, stable subpaths, and documented execution assets, never engine internals. These are the decision surfaces before wiring pyproc into a product.
Public surface map
Start from the task: which public exports to import, and which runnable proof backs that capability.
Capability matrix
Decide what to enable by product value, status, browser requirements, runnable surfaces, gates, and hard boundaries.
Consumer contract
Pin exact versions, keep import boundaries clean, deploy same-origin assets, and verify the product gate.
Benchmark contract
Reproduce S0-S5 artifacts before making speed claims. The headline is sharding and OS primitives, not blanket Python speed.
Install
Pin an exact npm version for product use. Release-before-pinning alternatives and asset deployment rules live in the consumer contract.