Research runtime for differentiable neural computers, GPU-based CPU emulation, and program synthesis. Features neural ALU, constant-time crypto, JEPA world models, and a self-hosting C compiler on Metal.
A complete computer in which every layer — arithmetic, OS, compiler, display — is either a trained neural network or runs entirely on GPU.
The model doesn't run on the computer. The model is the computer.
nCPU is one repository pursuing one thesis from five directions: a computer can be built out of learned components, and once the whole execution stack is differentiable, programs stop being things you write and become things you can search for by gradient descent. Each subsystem below stands on its own measurements; together they cover the stack from individual ALU operations to an operating system to program synthesis.
Every ALU operation — addition, subtraction, multiplication, bitwise logic, shifts, division — is a trained neural network. The neural OS (neurOS) manages memory, schedules processes, and compiles code through 11 trained models with no hand-written fallbacks. A neural display renders characters through char→glyph MLPs and a ConvNet (143K parameters). The full pipeline — source code → neural compiler → neural assembler → neural CPU → neural display — is differentiable end to end.
The neural ALU reaches 100% accuracy on 32-bit integer arithmetic, verified exhaustively over every possible input. One result inverts the conventional hardware hierarchy: multiplication is 12x faster than addition here, because addition needs an 8-pass carry chain while multiplication decomposes into parallel byte-pair table lookups.
| Instruction | Strategy | Latency |
|---|---|---|
| ADD/SUB/CMP | Kogge-Stone carry-lookahead (8 passes) | 248 µs |
| MUL | Byte-pair LUT (65,536 entries) | 21 µs |
| AND/OR/XOR | Vectorized truth table | 21 µs |
| SHL/SHR | Attention-based bit routing | 434 µs |
| DIV | Restoring division (neural subtraction) | varies |
neurOS component accuracy:
| Component | Accuracy | Component | Accuracy |
|---|---|---|---|
| MMU | 100% | Assembler codegen | 100% |
| TLB | 99.6% | Assembler tokenizer | 99.4% |
| Cache | 99.7% | Compiler optimizer | 95.2% |
| Scheduler | 99.2% | Watchdog | 100% |
| Prefetch | 97.8% | Block allocator | 98.4% |
A self-sufficient computer on a single GPU — the CPU is involved only at bootstrap. The Rust + Metal kernel executes about 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).
What runs on it:
nSynth is a Rust-based program synthesis system that discovers executable programs from input/output examples using gradient descent, enumeration, and search. Combined with a comprehensive ML/tensor engine and complete web stack, it enables synthesis of:
Coverage: 420/420 synthesis problems (Mog: 315/315, nSynth: 105/105)
Three Pillars:
cd nsynth
cargo run --release --bin nsynth_codegen --lang python --examples '{
"name":"reverse","signature":"fn reverse(arr: List<i64>) -> List<i64>",
"examples":[{"inputs":[[1,2,3]],"expected":[3,2,1]}]
}'
# → def reverse(arr): return arr[::-1]
The neural ALU injected into a transformer's forward pass as a routed expert. A learned per-token gate decides whether each token flows through the original MLP or through the neural ALU. Bilinear soft truth tables provide differentiable logic, tensor ops provide differentiable arithmetic, and gating is modulated by model confidence.
Results from an 11-model sweep across the Qwen 2.5/3/3.5 families, on arithmetic tasks:
| Model | Arithmetic accuracy | Note |
|---|---|---|
| Qwen3.5-2B (instruct) | 14.5% → 71.0% (+56.5 pp) | best overall |
| Qwen3.5-2B (base) | 15.5% → 63.0% (+47.5 pp) | 100% on ADD/SUB/MUL/DIV |
| Qwen3.5-4B | +51.0 pp | largest base-model gain (tied) |
| Qwen3.5-9B | +51.0 pp | largest base-model gain (tied) |
Real-world transfer is measured, not extrapolated: on full HumanEval (Qwen3.5-4B, A100), 62.2% → 64.6% — four additional problems solved.
A predictive world model of the computer itself. Alongside exact execution, a JEPA-style network (Joint Embedding Predictive Architecture) learns to predict machine state transitions in a compressed latent space:
latent_state_t + instruction → predictor → latent_state_{t+1}
It runs at two levels. A Python demo (ncpu/jepa_neural_cpu/) executes real
programs next to the predictor, turning prediction error into a live anomaly
signal. A Rust Metal implementation (kernels/rust_metal/src/jepa/, 2,858
lines) observes deterministic GPU execution and actively steers scheduling
through learned bias overrides.