The model doesn't run on the computer.
The model is the computer.

The hero demo: a UNIX machine on your GPU.

From demos/HERO_GPU_DEMO_TRANSCRIPT.md — the single highest-signal walkthrough of what makes nCPU unique. Every command below is real and runs today on Apple Silicon.

$ python -m ncpu gpu
# A real UNIX shell prompt running entirely on the Apple Silicon GPU
# via Metal compute shaders — ~1.9M instructions/sec for real C workloads.
# Run ls, cat, cc, compile programs, fork processes, use pipes.
# This is not "a program running on GPU". This is the operating system
# + hardware of a computer, implemented on the GPU.

$ python -m ncpu gpu debug
# The 26-command deterministic toolkit:
gpu-trace      gpu-history    gpu-replay     gpu-diff
gpu-break <a>  gpu-watch <a>  gpu-step
gpu-profile    gpu-stack      gpu-heat       gpu-coverage
gpu-taint      gpu-reverse    gpu-sanitize
gpu-const-time     # prove AES has zero timing leakage
gpu-timing-proof
# Why this is impossible on a normal CPU:
#  - every run is bit-identical (sigma = 0.0 cycle variance)
#  - full machine state persists after the program exits
#  - breakpoints / watchpoints have zero overhead (checked in-shader)
#  - diff two executions instruction-by-instruction, exact cycle counts
#  - post-mortem analysis on a process that already terminated

$ python -m ncpu gpu --neural-alu
# Neural weights active inside the Metal kernel:
#  ADD/SUB/CMP -> Kogge-Stone neural carry-lookahead (64-thread MLP)
#  MUL         -> byte-pair lookup tensor
#  AND/OR/XOR  -> learned truth tables
# Not an approximation: the integer ALU models are exhaustively
# verified to 100% accuracy on all inputs for their bit-width.
# The inversion you can observe: MUL is dramatically faster than ADD.

$ python -m ncpu gpu alpine --demo
# A real Alpine Linux v3.20 environment boots and runs on the GPU:
#  BusyBox as the multi-call binary; pipes, scripting, /proc.
# The GPU superpower commands are first-class inside this environment.
# This is the concrete existence proof of the thesis.

$ cd kernels/rust_metal
$ cargo run --bin ncpu_run -- --elf ../../demos/gpu/busybox.elf \
    --rootfs --interactive
# Bypasses Python entirely — the purest form of
# "the GPU is the computer."

A self-sufficient computer on a single GPU.

The Rust + Metal kernel executes ~200 ARM64 instructions (integer and floating-point) at roughly 1.9M instructions per second, with zero-copy shared memory and zero cycle-count variance across runs (σ = 0.0 over 270 runs). The CPU is involved only at bootstrap.

Also running on it: SHA-256, AES-128 (all 6 FIPS 197 vectors pass, T-table timing attacks have nothing to measure), Tetris, Snake, a Brainfuck interpreter, a Forth REPL, a CHIP-8 emulator, an HTTP server, and an MNIST classifier — ~11,300 lines of freestanding C in total. (Paper §13.4, §15)

neurOS: the operating system is trained, not written.

Memory management, scheduling, interrupts, caching, compilation, and monitoring implemented as trained models with 93.7–100% accuracy. In the v3.1 integration, eight neural models run live alongside the Metal kernel at 76K IPS. (Paper §9, §21)

Three components keep learning at runtime — the TLB, cache, and scheduler take single conservative gradient steps during normal operation. No conventional OS learns from its own scheduling decisions in real time. (Paper §9.11)

100% exact neural arithmetic — exhaustively verified.

The neural ALU reaches 100% accuracy on 32-bit integer arithmetic, verified exhaustively over every possible input. The trick is memorization-by-decomposition: break each operation into sub-problems with finite, enumerable input spaces (8-entry truth tables, 16-entry carry combiners, a 65,536-entry multiplication LUT), train each to 100%, and compose them structurally. Weights are frozen; sigmoid thresholds have >0.4 margins, so accuracy is permanent. (Paper §5–6)

MUXLEQ: Turing-complete in two instructions.

# MUXLEQ: the entire instruction set
SUBLEQ  [A] = [A] - [B]; if [A] <= 0, jump to C
MUX     [A] = ([B] AND [C]) OR (NOT [B] AND [D])

# In neural mode:
#   SUB -> arithmetic.pt + carry_combine.pt  (~248 µs/op)
#   MUX -> logical.pt neural AND/OR/NOT      (~63 µs/op)
# Loads .dec images. Boots eForth. 32 tests green.

JEPA: the computer predicts itself.

Alongside exact execution, a JEPA-style world model learns machine state transitions in a compressed latent space: latent_state_t + instruction → predictor → latent_state_t+1. A Python demo turns prediction error into a live anomaly signal; a Rust Metal implementation (kernels/rust_metal/src/jepa/, 2,858 lines) observes deterministic GPU execution and steers scheduling through learned bias overrides.

Because the substrate underneath is exact, this world model gets what most lack: unlimited free ground truth (just run more programs), and the ability to mix predicted and exact execution at will — cheap latent speculation when exploring, exact execution when it matters.

Run it yourself.

macOS / Apple Silicon for the Metal path. Everything below is in the repo README.

pip install -e ".[demo,dev]"

# The headline demo: the GPU as a complete computer
python -m ncpu gpu                 # boot it
python -m ncpu gpu --neural-alu    # neural ALU inside the Metal shader
python -m ncpu gpu debug           # 26-command deterministic debugger
python -m ncpu gpu alpine --demo   # Alpine Linux v3.20 on the GPU

# JEPA predictive layer
python3 -m ncpu.jepa_neural_cpu.demo
python -m ncpu.world_model.quickstart

# Rust-native, no Python required
cd kernels/rust_metal
cargo run --bin ncpu_run -- --elf ../../demos/gpu/busybox.elf --rootfs -- echo hello