nCPU

Ein vollständiger Computer, bei dem jede Schicht – Arithmetik, Betriebssystem, Compiler, Display – entweder ein trainiertes neuronales Netz ist oder vollständig auf der GPU läuft.
Das Modell läuft nicht auf dem Computer. Das Modell ist der Computer.

nCPU ist ein Repository, das eine These aus fünf Richtungen verfolgt: Ein Computer kann aus gelernten Komponenten aufgebaut werden, und sobald der gesamte Ausführungsstapel differenzierbar ist, hören Programme auf, Dinge zu sein, die man schreibt, und werden zu Dingen, die man mittels Gradientenabstieg suchen kann. Jedes der folgenden Subsysteme basiert auf eigenen Messungen; zusammen decken sie den Stapel von einzelnen ALU-Operationen über ein Betriebssystem bis hin zur Programmsynthese ab.

Die fünf Subsysteme

1. Der neuronale Computer

Jede ALU-Operation – Addition, Subtraktion, Multiplikation, bitweise Logik, Verschiebungen, Division – ist ein trainiertes neuronales Netz. Das neuronale Betriebssystem (neurOS) verwaltet Speicher, plant Prozesse und kompiliert Code durch 11 trainierte Modelle ohne handgeschriebene Rückfallebene. Ein neuronales Display rendert Zeichen durch Char→Glyph-MLPs und ein ConvNet (143K Parameter). Die gesamte Pipeline – Quellcode → neuronaler Compiler → neuronaler Assembler → neuronale CPU → neuronales Display – ist durchgängig differenzierbar.

Die neuronale ALU erreicht 100 % Genauigkeit bei 32-Bit-Ganzzahlarithmetik, die exhaustiv über jede mögliche Eingabe verifiziert wurde. Ein Ergebnis kehrt die herkömmliche Hardware-Hierarchie um: Multiplikation ist hier 12-mal schneller als Addition, weil Addition eine 8-stufige Übertragskette benötigt, während Multiplikation in parallele Byte-Paar-Tabellennachschlagen zerlegt wird.

Genauigkeit der neurOS-Komponenten:

2. Der GPU-Computer

Ein autarker Computer auf einer einzigen GPU – die CPU wird nur beim Bootstrapping benötigt. Der Rust+Metal-Kernel führt etwa 200 ARM64-Befehle (Ganzzahl- und Gleitkommazahlen) mit etwa 1,9 Mio. Befehle pro Sekunde aus, mit Zero-Copy-Shared-Memory und Null-Zyklusvarianz zwischen Läufen (σ = 0,0).

Was darauf läuft:

• Ein Multi-Prozess-UNIX-Betriebssystem: fork/pipe/wait, eine Shell mit 25 Befehlen, 28 Systemaufrufe, bis zu 15 gleichzeitige Prozesse
• Ein sich selbst hostender C-Compiler (~4.200 Zeilen), der sich selbst kompiliert, dann andere Programme kompiliert und ausführt – vollständig auf der GPU
• Echte Linux-Binärdateien über einen ELF64-Lader: BusyBox (264 KB, 34+ Befehle) und Alpine Linux v3.20
• 13+ kompilierte C-Anwendungen: SHA-256, AES-128, Tetris, Snake, ein Brainfuck- Interpreter, ein Forth-REPL, ein CHIP-8-Emulator, ein HTTP-Server, ein MNIST- Klassifikator und andere
• Ein deterministischer Debugger mit 26 Befehlen: Befehlsverfolgung, Breakpoints und Watchpoints, Time-Travel-Debugging, ein Memory-Sanitizer, automatisiertes Fuzzing, reverse Datenflussanalyse und Constant-Time-Überprüfung. Deterministische Ausführung macht Time-Travel und exaktes Replay möglich; herkömmliche CPUs mit Cache- und spekulationsbedingtem Timing-Rauschen können nicht die gleichen Garantien bieten.

3. nSynth: Universelle Synthese-Engine

nSynth ist ein Rust-basiertes Programmsynthesesystem, das ausführbare Programme aus Eingabe-/Ausgabebeispielen durch Gradientenabstieg, Enumeration und Suche entdeckt. In Kombination mit einer umfassenden ML-/Tensor-Engine und einem vollständigen Web-Stack ermöglicht es die Synthese von:

• Algorithmen: Arithmetik, Bitoperationen, Datenstrukturen, Algorithmen
• ML-Modellen: CNNs, RNNs, Transformer, GNNs, Diffusion, Flows, RL-Agenten
• Web-Apps: Full-Stack React/Next.js, APIs, Styling, WebGL, WASM-Anwendungen

Abdeckung: 420/420 Syntheseprobleme (Mog: 315/315, nSynth: 105/105)

Drei Säulen:

1. Programmsynthese (Kern): 105/105 Probleme gelöst durch gradientenbasiertes Suchen, enumberative Synthese, Vorlagenabgleich und Suchfamilien
2. ML-/Tensor-Engine (1000+ APIs): Umfassende Tensoroperationen mit automatischer Differenzierung, die die Synthese JEDER ML-Architektur ermöglicht:
   • Aufmerksamkeitsmechanismen (MultiHeadAttention, RoPE, ALiBi, FlashAttention, Linformer, Performer)
   • Generative Modelle (Diffusion DDPM/DDIM, Normalizing Flows RealNVP/MAF, Neural ODE)
   • Vision (3D Conv, Deformable Conv, Fourier Features, NeRF Volumenrendering)
   • RL (Policy Gradients, PPO, A3C, Experience Replay, GAE, Value Functions)
   • Meta-Learning (MAML, Reptile, DARTS, ENAS NAS)
   • Probabilistisches ML (Bayesian NN, MC Dropout, Variational Inference, KL-Divergenz)
   • Effizienz (Pruning, Quantisierung, Knowledge Distillation, Verteiltes Training)
3. Web-Stack (500+ APIs): Full-Stack-Web-Synthese mit vollständiger Abdeckung:
   • Kern: HTTP, WebSocket, SSL, JSON, Cookies, Formulare, Middleware
   • Frameworks: React, Vue, Svelte, Solid, Next.js, Remix
   • Modern: WASM, WebGPU, WebAuthn, WebRTC, PWA
   • APIs: GraphQL, gRPC, tRPC, OpenAPI
   • Styling: CSS, Tailwind, responsive, Dark Mode
   • Bundling: Vite, webpack, esbuild

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]

4. Der differenzierbare Koprozessor

Die neuronale ALU wird in den Forward-Pass eines Transformers injiziert, als gerouteter Experte. Ein gelerntes, tokenweises Gate entscheidet, ob jedes Token durch das ursprüngliche MLP oder durch die neuronale ALU fließt. Bilineare Soft-Wahrheitstabellen bieten differenzierbare Logik, Tensor-Operationen differenzierbare Arithmetik, und die Gattersteuerung wird durch die Modellkonfidenz moduliert.

Ergebnisse aus einem 11-Modell-Durchlauf über die Qwen-2.5/3/3.5-Familien bei arithmetischen Aufgaben:

Die reale Übertragbarkeit wird gemessen, nicht extrapoliert: Bei vollständigem HumanEval (Qwen3.5-4B, A100) stieg 62,2 % auf 64,6 % – vier zusätzlich gelöste Probleme.

5. JEPA-vorhersagende Maschinendynamik

Ein vorhersagendes Weltmodell des Computers selbst. Neben der exakten Ausführung lernt ein JEPA-ähnliches Netzwerk (Joint Embedding Predictive Architecture), Zustandsübergänge der Maschine in einem komprimierten latenten Raum vorherzusagen:

latent_state_t + instruction → predictor → latent_state_{t+1}

Es läuft auf zwei Ebenen. Eine Python-Demo (ncpu/jepa_neural_cpu/) führt echte Programme neben dem Prädiktor aus und verwandelt den Vorhersagefehler in ein Live-Anomaliesignal. Eine Rust-Metal-Implementierung (kernels/rust_metal/src/jepa/, 2.858 Zeilen) beobachtet deterministische GPU-Ausführung und steuert aktiv die Planung durch gelernte Bias-Überschreibungen.

Da das Substrat darunter exakt ist, hat dieses Weltmodell zwei Eigenschaften, den meisten fehlen: unbegrenzt freie Grundwahrheit (mehr Programme ausführen) und die Möglichkeit, vorhergesagte und exakte Ausführung nach Belieben zu mischen – günstige latente Spekulation beim Erkunden, exakte Ausführung, wenn es darauf ankommt. Das langfristige Ziel ist eine Hierarchie von Prädiktoren auf Bit-, Befehl-, Programm- und Aufgabenebene.

python3 -m ncpu.jepa_neural_cpu.demo     # Bottom-up JEPA neuronaler Computer-Demo
python -m ncpu.world_model.quickstart    # JEPA-Maschinenweltmodell-Schnellstart

In 60 Sekunden starten

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

# Das Haupt-Demo: die GPU als vollständiger Computer (macOS / Apple Silicon)
python -m ncpu gpu                 # Booten
python -m ncpu gpu --neural-alu    # Mit neuronaler ALU im Metal-Shader
python -m ncpu gpu debug           # 26-Befehl-deterministischer Debugger

# Plattformübergreifend, keine schweren Abhängigkeiten
python -m ncpu discover            # Programm durch Beispiele, mittels differenzierbarer Synthese
python -m ncpu text --interactive  # Neuronales Text-/Chiffrier-System

# Vollständige neuronale Pipeline (benötigt den Modellstack)
python -m ncpu full-neural         # Bottom-up neuronale CPU + neuronales Display
python -m ncpu meta-compare        # Side-by-Side-Vergleichs-Demo

# JEPA-vorhersagende Schicht
python3 -m ncpu.jepa_neural_cpu.demo
python -m ncpu.world_model.quickstart

# Rust-nativ, kein Python erforderlich
cd kernels/rust_metal
cargo run --bin ncpu_run -- --elf ../../demos/gpu/busybox.elf --rootfs -- echo hello

Drei Ausführungsmodi

Alle drei führen die gleichen Programme aus und liefern die gleichen Ergebnisse. Der neuronale Modus sendet jede Operation durch trainierte Netze. Der schnelle Modus verwendet native Tensoren mit derselben ISA und derselben Differenzierbarkeit. Der Compute-Modus tauscht Gradientenfluss gegen Geschwindigkeit – hier bootet das UNIX-Betriebssystem, der Compiler hostet sich selbst und BusyBox läuft.

# Neuronaler Modus – jede Operation ist ein trainiertes Modell
from ncpu.model import CPU
cpu = CPU(neural_execution=True)
cpu.load_program("MOV R0, 7\nMOV R1, 6\nMUL R2, R0, R1\nHALT")
cpu.run()
print(cpu.get_register("R2"))  # 42 – berechnet durch die neuronale Byte-Paar-Nachschlagetabelle

# Differenzierbarer Koprozessor – in jedes Hugging-Face-Modell injizieren
from ncpu.coprocessor import inject_ncpu_coprocessor, NCPUCoprocessorConfig
config = NCPUCoprocessorConfig(confidence_aware=True, deterministic_alu=True)
inject_ncpu_coprocessor(model, config)

# Differenzierbare Programmsynthese
from ncpu.differentiable import ProgramSynthesizer, SynthesisSpec
spec = SynthesisSpec(examples=[
    ({0: 3.0, 1: 5.0}, {2: 8.0}),
    ({0: 7.0, 1: 2.0}, {2: 9.0}),
])
synth = ProgramSynthesizer(max_program_len=6)
result = synth.synthesize(spec, max_iters=2000)
# entdeckt: ADD R2, R0, R1; HALT

# JEPA-Weltmodell – Vorhersage von Maschinenzustandsübergängen
from ncpu.world_model.je_world_model import JEWorldModel, JEWMConfig
model = JEWorldModel(JEWMConfig(state_dim=22, action_dim=8))
pred = model.predict_next_latent(model.encode_state(state), model.encode_action(action))

Der vollständige Stack

Timing-Nebenkanal-Immunität

GPU-Ausführung produziert hier keine Zykluszahl-Varianz – σ = 0,0 über 270 Läufe, während derselbe Code auf nativen Apple Silicon 47–73 % Timing-Varianz aufweist. Ohne Daten-Cache gibt es keine Cache-Zeilen und keine Cache-Fehler-Strafe, sodass AES-T-Tabellen-Angriffe nichts zu messen haben.

Darauf aufbauend bietet ncpu/crypto/ Constant-Time-AES-128 (ECB und CBC) aus 19 Constant-Time-Primitiven, die alle FIPS 197- und NIST SP 800-38A-Testvektoren bestehen.

Self-Optimizing Machine Engine (SOME)

Ein versteckter Controller, der einen Teil der neuronalen Maschine in einen internen Koprozessor für Codegenerierung verwandelt: eine gepufferte Denken → Schreiben → Verifizieren → Patchen → Festschreiben- Schleife, gelernte Aktion-/Halt-/Deskriptor-/Zustands-Patch-/Speicher-Köpfe und aufgabenlokale schnelle Gewichte, die während der Inferenz aktualisiert werden. Der gelernte Speicherkopf verbesserte den Validierungs-MSE um 83,26 % gegenüber der Basislinie.

End-to-End gemessen: HumanEval+ für qwen3.5:4b verbesserte sich von 147 auf 154 und für qwen3.5:9b von 144 auf 156; BigCodeBench-Hard für qwen3.5:9b verbesserte sich von 33 auf 49.

MUXLEQ: Turing-vollständig mit zwei Befehlen

SUBLEQ plus MUX, läuft in allen drei Ausführungsmodi. Im neuronalen Modus durchläuft SUB die Kogge-Stone-Übertragsvorausberechnung (~248 µs) und MUX neuronale AND/OR/NOT (~63 µs). Es lädt .dec-Images und bootet eForth. Der Punkt: Wenn trainierte Netze exakt einen Zwei-Befehl-Ein-Befehlssatz-Computer ausführen, erstreckt sich die Konstruktion auf jeden Befehlssatz.

Programmsynthese aus Beispielen (nsynth_codegen)

cargo build --release --bin nsynth_codegen
./target/release/nsynth_codegen --lang python --examples '{
  "name":"square","signature":"fn square(x: i64) -> i64",
  "examples":[{"inputs":[0],"expected":0},{"inputs":[3],"expected":9}]
}'
# → def square(x: int): return (0 * x * x) + (1 * x * x) + 0

Projektstruktur

ncpu/
  differentiable/    # Differenzierbare Ausführung, Programmsynthese, ISA-Entdeckung
  coprocessor/       # nCPU in Transformer-Forward-Pässe injizieren
  execution_training/# Differenzierbare Ausführung als Trainingssignal für Code-Sprachmodelle
  crypto/            # Constant-Time-Kryptographie (AES-128)
  distributed/       # Multi-GPU verteilte Ausführung
  jepa_neural_cpu/   # Bottom-up JEPA neuronaler Computer-Demo
  world_model/       # JEPA-Maschinenweltmodell (vorhersagende Dynamik)
  autoresearch/      # Automatisierte Forschung + zusammengesetzte NPCoT-Schleife
  os/
    neuros/          # Neuronales Betriebssystem: 17 Module (MMU, TLB, Cache, Scheduler, ...)
    gpu/             # GPU UNIX-Betriebssystem: Shell, Dateisystem, ELF-Lader, C-Quellcode
  self_optimizing/   # SOME: versteckter Controller, schnelle Gewichte
  neural/            # NeuralCPU: neuronale ALU-Brücke, Web-Pipeline
  model/             # Modellbasierte CPU (neural_ops, Assembler)
  tensor/            # Tensor-basierter ARM64-Emulator (differenzierbar)

# Kompilierte / beschleunigte Backends
kernels/             # rust_metal (Rust+Metal ARM64-Kernel), mlx, npcot_wasm
nsynth/              # Universelle Synthese-Engine: gradientenbasiert + enumerativ + Suche + ML + Web
                     # 420/420 Syntheseabdeckung, 1000+ ML-APIs, 500+ Web-APIs
                     # Kern: Programmsynthese (105/105), ML/Tensor (18+ Module), Web (19+ Module)
                     # Universelles ML: Aufmerksamkeit, Diffusion, Flows, ODEs, NeRF, RL, Meta-Learning
                     # Vollständiges Web: WASM, WebGPU, Frameworks, APIs, Styling, Bundling
packages/            # Begleitpakete (metal_mlp)

# Modelle & Synthesekorpus
models/              # Trainierte neuronale Komponentengewichte (siehe models/MODEL_INDEX.md)
programs/            # Synthese-Benchmark-Korpus (Arithmetik, Bitoperationen, Algorithmen, ...)

# Belege, Paper, Experimente
artifacts/           # Festgeschriebene Benchmark-Ergebnisse, die im Paper zitiert werden + Tests
paper/               # Forschungspapier + modulare Abschnitte
benchmarks/          # Benchmark-Treiberskripte
experiments/         # Erkundende Experimentläufe

# Verwendung & Betrieb
examples/            # Minimale ausführbare Demos (einer pro Ausführungspfad)
demos/               # Größere Showcase-Durchgänge (BusyBox, Alpine, Compiler)
scripts/             # Einstiegspunkte + Automatisierung für Betreuer
tools/               # Entwicklerwerkzeuge
training/            # Trainingspipelines
packaging/           # Bereitstellungsgerüst (Homebrew, Modal, DEPLOYMENT.md)

# Tests, Dokumentation, Assets
tests/               # Testsuite (siehe tests/README.md)
docs/                # Dokumentation
assets/              # Logos / statische Assets

# Build- & Laufzeitausgabe (gitignoriert – regenerierbar, nicht festgeschrieben)
checkpoints/         # Große `.pt`-Gewichts-Checkpoints
training_results/    # Koprozessor-Skalierungsdurchläufe, Ablationsstudien
dist/                # Build-Distributionen
logs/  outputs/      # Ausführungsprotokolle und Zwischenausgaben

Jedes Verzeichnis der obersten Ebene hat eine eigene README.md, die seinen Zweck beschreibt.

Tests

python -m ncpu doctor
pytest tests/ -q   # 2.500+ Tests über den gesamten Stack

Die Abdeckung umfasst exhaustive formale Verifikation der ALU, neuronale Operationen, neurOS, Compute-Modus, Mehrprozessausführung, MUXLEQ, BusyBox/Alpine, das GPU-Debugging-Toolkit, den Koprozessor, Mog-Synthese, differenzierbare Ausführung, Constant-Time-Kryptographie, selbstmodifizierende Programme, den diff-Compiler, Multi-GPU-Verteilung, SOME und die JEPA-vorhersagenden Modelle.

Dokumentation

• Forschungspapier – die vollständige Analyse und Ergebnisse
• GPU-Debugging-Toolkit-Papier – der 26-Befehl-GPU-native Debugger
• GPU-Debugging-Toolkit-Referenz – Befehlsreferenz
• Rust-Metal-Kernel – Architektur, Zero-Copy-Design, Build-Anleitung
• Kompilierungspipeline – End-to-End-C-zu-GPU-Fluss
• JEPA-neuronale-CPU – Bottom-up neuronale Computerarchitektur
• JEPA-Maschinenweltmodell – Design der vorhersagenden Dynamik
• Modellindex – vollständiges Bestandsverzeichnis trainierter Modelle
• SOME-vollständige-Anleitung – versteckter Controller und Trainingspipeline
• Differenzierbare Programme – Programmoptimierung, Synthese, ISA-Entdeckung
• Benchmark-Ergebnisse – pass@1-Zahlen für jeden Modus und jede Modellstufe

Lizenz

MIT