01
OWN
One worker.
One kernel owner.
The interpreter and linear memory stay behind a versioned worker protocol. Consumers receive typed values and receipts, never raw heap access or live Python proxies.
Run the kernel ↗PYPROC / BROWSER-NATIVE MACHINE
The browser now owns
its Python kernel.
Run source-built CPython in a dedicated worker. Transfer typed values, checkpoint the interpreter, clone independent processes, and carry state in a verified Machine image.
- Real CPython
- No application server
- Exact-version native ESM
- Chromium / Edge
live machine
ready in this tab
Loading the Machine...
ONE MACHINE OWNS
- execution
- workspace
- environment
- processes
- history
- image
THE PRODUCT MODEL
One Machine,
complete lifecycle.
A runtime becomes a computer when its work survives, its history can move in both directions, and the result can leave the browser intact.
- 01Boot
Verify the owned engine manifest and start CPython in its worker.
await boot() - 02Work
Run CPython through a Promise-first kernel contract.
await machine.run(code) - 03Checkpoint
Seal an execution boundary into content-addressed state.
await history.checkpoint() - 04Clone
Open prepared state in an independent worker process.
await machine.proc.clone() - 05Carry
Export state and integrity metadata as a Machine image.
await history.export()
WHAT CHANGES
Python stops being a disposable tab.
pyproc changes the physical properties around the interpreter. The language stays Python. The surrounding Machine gains continuity, history, processes, and a portable identity.
One worker.
02
REWIND
Mistakes become
another branch.
Checkpoint the prepared heap, let an attempt fail, then restore changed pages. Compare several futures from one clean origin and adopt only the result you want.
Run the agent loop ↗03
PARALLELIZE
One snapshot.
Independent processes.
A Web Worker is a process. Fork a prepared interpreter into independent workers, each with its own interpreter and GIL, then interrupt or replace them as a real process pool.
Open Process OS ↗04
CARRY
The image carries
the prepared state.
A Machine image carries checkpoint objects, engine identity, and integrity metadata without embedding the engine binary.
Export a Machine ↗RUNNABLE PROOF
Do not take the landing page's word for it.
Each surface below runs the public package in your browser. They are not mockups, recordings, or backend sessions.
01 / REVIVAL
Revived Python Machine
Export a checkpoint and reopen the same state in a fresh worker.
Open demo ↗ 02 / HISTORYAgent sandbox loop
Prepare, fail, rewind, branch, compare, and adopt.
Open demo ↗ 03 / PROCESSESProcess OS
Fork independent interpreters across real CPU cores.
Open demo ↗ 04 / SERVERIn-kernel web app
Serve FastAPI through a real browser URL with no backend.
Open demo ↗FOR PRODUCT BUILDERS
Build on the Machine contract
Use the gathered root entrances, named plumbing subpaths, and documented execution assets, never engine internals. These are the boundaries for extending pyproc without fragmenting the product.
01↗
02↗
03↗
04↗
Product entrances
Choose the public door by task and see the runnable proof behind it.
Capability matrix
Compare product value, browser requirements, status, and hard boundaries.
Package contract
Pin exact versions, keep imports clean, and deploy verified same-origin assets.
Benchmark contract
Measure the structure honestly without turning temporary numbers into product claims.
START HERE
Put a Python Machine
inside your product.
Pin an exact npm version. The package has no runtime npm dependencies and ships as native ESM without a build step.
npm install pyproc// boot the verified worker-owned kernel
import { boot } from "pyproc";
const machine = await boot();
const result = await machine.run("print(6 * 7)");
console.log(result.output);Pin an exact npm version. Release-before-pinning alternatives and asset deployment rules live in the package contract.