nCPU

Un computer completo in cui ogni strato — aritmetica, sistema operativo, compilatore, display — è o una rete neurale addestrata o esegue interamente su GPU.
Il modello non viene eseguito sul computer. Il modello è il computer.

nCPU è un repository che persegue una tesi da cinque direzioni: un computer può essere costruito con componenti appresi, e una volta che l'intero stack di esecuzione è differenziabile, i programmi smettono di essere cose che scrivi e diventano cose che puoi cercare tramite discesa del gradiente. Ogni sottosistema sotto si basa su misurazioni proprie; insieme coprono lo stack dalle singole operazioni ALU a un sistema operativo fino alla sintesi di programmi.

I cinque sottosistemi

1. Il computer neurale

Ogni operazione ALU — addizione, sottrazione, moltiplicazione, logica bit a bit, shift, divisione — è una rete neurale addestrata. Il sistema operativo neurale (neurOS) gestisce la memoria, pianifica i processi e compila il codice attraverso 11 modelli addestrati con nessun fallback scritto a mano. Un display neurale visualizza i caratteri tramite MLP char→glyph e una ConvNet (143K parametri). L'intera pipeline — codice sorgente → compilatore neurale → assemblatore neurale → CPU neurale → display neurale — è differenziabile end-to-end.

L'ALU neurale raggiunge il 100% di accuratezza sull'aritmetica intera a 32 bit, verificata esaustivamente su ogni possibile input. Un risultato inverte la gerarchia hardware convenzionale: la moltiplicazione è 12x più veloce dell'addizione qui, perché l'addizione necessita di una catena di riporto a 8 passaggi mentre la moltiplicazione si scompone in lookup paralleli di coppie di byte.

Accuratezza dei componenti neurOS:

2. Il computer GPU

Un computer autosufficiente su una singola GPU — la CPU è coinvolta solo al bootstrap. Il kernel Rust + Metal esegue circa 200 istruzioni ARM64 (intere e a virgola mobile) a circa 1,9 milioni di istruzioni al secondo, con memoria condivisa a copia zero e varianza zero del conteggio dei cicli tra esecuzioni (σ = 0,0).

Cosa viene eseguito su di esso:

• Un sistema operativo UNIX multi-processo: fork/pipe/wait, una shell a 25 comandi, 28 syscall, fino a 15 processi concorrenti
• Un compilatore C auto-ospitato (~4.200 righe) che compila se stesso, poi compila ed esegue altri programmi — interamente sulla GPU
• Binari Linux reali tramite un caricatore ELF64: BusyBox (264KB, 34+ comandi) e Alpine Linux v3.20
• 13+ applicazioni C compilate: SHA-256, AES-128, Tetris, Snake, un interprete Brainfuck, un REPL Forth, un emulatore CHIP-8, un server HTTP, un classificatore MNIST e altri
• Un debugger deterministico a 26 comandi: tracciamento delle istruzioni, breakpoint e watchpoint, debug con viaggio nel tempo, un memory sanitizer, fuzzing automatizzato, analisi inversa del flusso di dati e verifica a tempo costante. L'esecuzione deterministica è ciò che rende possibile il viaggio nel tempo e la riproduzione esatta; le CPU convenzionali, con rumore temporale indotto da cache e speculazione, non possono offrire le stesse garanzie.

3. nSynth: Motore di sintesi universale

nSynth è un sistema di sintesi di programmi basato su Rust che scopre programmi eseguibili da esempi input/output utilizzando discesa del gradiente, enumerazione e ricerca. Combinato con un motore ML/tensore completo e uno stack web completo, abilita la sintesi di:

• Algoritmi: Aritmetica, bitwise, strutture dati, algoritmi
• Modelli ML: CNN, RNN, Transformers, GNN, Diffusione, Flussi, Agenti RL
• App Web: React/Next.js full-stack, API, styling, applicazioni WebGL, WASM

Copertura: 420/420 problemi di sintesi (Mog: 315/315, nSynth: 105/105)

Tre pilastri:

1. Sintesi di programmi (Core): 105/105 problemi risolti tramite ricerca basata su gradiente, sintesi enumerativa, corrispondenza di template e famiglie di ricerca
2. Motore ML/Tensore (1000+ API): Operazioni tensoriali complete con differenziazione automatica, abilitando la sintesi di QUALSIASI architettura ML:
   • Meccanismi di attenzione (MultiHeadAttention, RoPE, ALiBi, FlashAttention, Linformer, Performer)
   • Modelli generativi (Diffusione DDPM/DDIM, Flussi normalizzanti RealNVP/MAF, ODE neurale)
   • Visione (Conv 3D, Conv deformabile, Caratteristiche di Fourier, rendering volumetrico NeRF)
   • RL (Policy Gradients, PPO, A3C, Experience Replay, GAE, Funzioni valore)
   • Meta-apprendimento (MAML, Reptile, DARTS, ENAS NAS)
   • ML probabilistico (Bayesian NN, MC Dropout, Inferenza variazionale, Divergenza KL)
   • Efficienza (Pruning, Quantizzazione, Distillazione della conoscenza, Addestramento distribuito)
3. Stack Web (500+ API): Sintesi web full-stack con copertura completa:
   • Core: HTTP, WebSocket, SSL, JSON, Cookie, Form, Middleware
   • Framework: React, Vue, Svelte, Solid, Next.js, Remix
   • Moderno: WASM, WebGPU, WebAuthn, WebRTC, PWA
   • API: GraphQL, gRPC, tRPC, OpenAPI
   • Styling: CSS, Tailwind, responsive, modalità scura
   • 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. Il coprocessore differenziabile

L'ALU neurale iniettata nel forward pass di un trasformatore come esperto instradato. Un gate appreso per token decide se ogni token passa attraverso il MLP originale o attraverso l'ALU neurale. Le tavole di verità soft bilineari forniscono logica differenziabile, le operazioni tensoriali forniscono aritmetica differenziabile, e il gating è modulato dalla confidenza del modello.

Risultati da una sweep su 11 modelli attraverso le famiglie Qwen 2.5/3/3.5, su compiti aritmetici:

Il trasferimento nel mondo reale è misurato, non estrapolato: su HumanEval completo (Qwen3.5-4B, A100), 62,2% → 64,6% — quattro problemi aggiuntivi risolti.

5. Dinamiche predittive della macchina JEPA

Un modello del mondo predittivo del computer stesso. Accanto all'esecuzione esatta, una rete in stile JEPA (Joint Embedding Predictive Architecture) impara a predire le transizioni di stato della macchina in uno spazio latente compresso:

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

Funziona a due livelli. Una demo Python (ncpu/jepa_neural_cpu/) esegue programmi reali accanto al predittore, trasformando l'errore di predizione in un segnale di anomalia in tempo reale. Un'implementazione Rust Metal (kernels/rust_metal/src/jepa/, 2.858 righe) osserva l'esecuzione deterministica della GPU e guida attivamente la pianificazione tramite override di bias appresi.

Poiché il substrato sottostante è esatto, questo modello del mondo ha due proprietà che la maggior parte non ha: quantità illimitata di verità di base gratuita (esegui più programmi) e la capacità di mescolare esecuzione predetta ed esatta a piacere — speculazione latente economica quando si esplora, esecuzione esatta quando è importante. La direzione a lungo termine è una gerarchia di predittori a livello di bit, istruzione, programma e compito.

python3 -m ncpu.jepa_neural_cpu.demo     # demo JEPA bottom-up del computer neurale
python -m ncpu.world_model.quickstart    # avvio rapido del modello del mondo JEPA

Inizia in 60 secondi

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

# La demo principale: la GPU come computer completo (macOS / Apple Silicon)
python -m ncpu gpu                 # avvialo
python -m ncpu gpu --neural-alu    # con l'ALU neurale dentro lo shader Metal
python -m ncpu gpu debug           # debugger deterministico a 26 comandi

# Multipiattaforma, nessuna dipendenza pesante
python -m ncpu discover            # programma tramite esempi, tramite sintesi differenziabile
python -m ncpu text --interactive  # macchina neurale testo/cifrario

# Pipeline neurale completa (richiede lo stack di modelli)
python -m ncpu full-neural         # CPU neurale bottom-up + display neurale
python -m ncpu meta-compare        # demo di confronto affiancato

# Strato predittivo JEPA
python3 -m ncpu.jepa_neural_cpu.demo
python -m ncpu.world_model.quickstart

# Rust nativo, nessun Python richiesto
cd kernels/rust_metal
cargo run --bin ncpu_run -- --elf ../../demos/gpu/busybox.elf --rootfs -- echo hello

Tre modalità di esecuzione

Tutte e tre eseguono gli stessi programmi e producono gli stessi risultati. La modalità neurale invia ogni operazione attraverso reti addestrate. La modalità veloce utilizza tensori nativi con lo stesso ISA e la stessa differenziabilità. La modalità compute scambia il flusso del gradiente per velocità — è dove il sistema operativo UNIX si avvia, il compilatore si auto-ospita e BusyBox viene eseguito.

# Modalità neurale — ogni operazione è un modello addestrato
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 — calcolato dalla LUT neurale a coppie di byte

# Coprocessore differenziabile — inietta in qualsiasi modello Hugging Face
from ncpu.coprocessor import inject_ncpu_coprocessor, NCPUCoprocessorConfig
config = NCPUCoprocessorConfig(confidence_aware=True, deterministic_alu=True)
inject_ncpu_coprocessor(model, config)

# Sintesi di programmi differenziabile
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)
# scopre: ADD R2, R0, R1; HALT

# Modello del mondo JEPA — predici le transizioni di stato della macchina
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))

Lo stack completo

Immunità al canale laterale temporale

L'esecuzione su GPU qui produce varianza zero del conteggio dei cicli — σ = 0.0 su 270 esecuzioni, dove lo stesso codice su Apple Silicon nativo mostra una varianza temporale del 47–73%. Con nessuna cache dati, non ci sono linee di cache e nessuna penalità per cache miss, quindi gli attacchi alle tabelle T di AES non hanno nulla da misurare.

Costruito su questa proprietà, ncpu/crypto/ fornisce AES-128 a tempo costante (ECB e CBC) da 19 primitive a tempo costante, superando tutti i vettori di test FIPS 197 e NIST SP 800-38A.

Motore auto-ottimizzante (SOME)

Un controller nascosto che trasforma parte della macchina neurale in un coprocessore interno per la generazione di codice: un ciclo bufferizzato pensa → scrivi → verifica → correggi → commit, testine apprese di azione/halt/descrittore/patch-stato/memoria e pesi veloci locali al compito aggiornati durante l'inferenza. La testina di memoria appresa ha migliorato l'MSE di validazione dell'83,26% rispetto alla baseline.

Misurato end-to-end: HumanEval+ per qwen3.5:4b migliorato da 147 a 154 e per qwen3.5:9b da 144 a 156; BigCodeBench-Hard per qwen3.5:9b migliorato da 33 a 49.

MUXLEQ: Turing-completo in due istruzioni

SUBLEQ più MUX, eseguito in tutte e tre le modalità di esecuzione. In modalità neurale, SUB passa attraverso il carry-lookahead Kogge-Stone (~248 µs) e MUX attraverso AND/OR/NOT neurali (~63 µs). Carica immagini .dec e avvia eForth. Il punto: se le reti addestrate eseguono esattamente un computer a due istruzioni e un set di istruzioni, la costruzione si estende a qualsiasi set di istruzioni.

Sintesi di programmi da esempi (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

Struttura del progetto

ncpu/
  differentiable/    # Esecuzione differenziabile, sintesi programmi, scoperta ISA
  coprocessor/       # Inietta nCPU nei forward pass dei transformer
  execution_training/# Esecuzione differenziabile come segnale di training per LM di codice
  crypto/            # Crittografia a tempo costante (AES-128)
  distributed/       # Esecuzione distribuita multi-GPU
  jepa_neural_cpu/   # Demo JEPA bottom-up del computer neurale
  world_model/       # Modello del mondo JEPA (dinamiche predittive)
  autoresearch/      # Ricerca automatizzata + ciclo NPCoT composto
  os/
    neuros/          # Sistema operativo neurale: 17 moduli (MMU, TLB, cache, scheduler...)
    gpu/             # Sistema operativo UNIX su GPU: shell, filesystem, caricatore ELF, sorgente C
  self_optimizing/   # SOME: controller nascosto, pesi veloci
  neural/            # NeuralCPU: ponte ALU neurale, pipeline weave
  model/             # CPU basata su modello (neural_ops, assembler)
  tensor/            # Emulatore ARM64 basato su tensori (differenziabile)

# Backend compilati / accelerati
kernels/             # rust_metal (kernel Rust+Metal ARM64), mlx, npcot_wasm
nsynth/              # Motore di sintesi universale: gradiente + enumerativo + ricerca + ML + web
                     # Copertura sintesi 420/420, 1000+ API ML, 500+ API web
                     # Core: sintesi programmi (105/105), ML/tensori (18+ moduli), web (19+ moduli)
                     # ML universale: attenzione, diffusione, flussi, ODE, NeRF, RL, meta-apprendimento
                     # Web completo: WASM, WebGPU, framework, API, styling, bundling
packages/            # Pacchetti compagni (metal_mlp)

# Modelli e corpus di sintesi
models/              # Pesi dei componenti neurali addestrati (vedi models/MODEL_INDEX.md)
programs/            # Corpus di benchmark di sintesi (aritmetica, bitwise, algoritmi, ...)

# Evidenze, articolo, esperimenti
artifacts/           # Risultati di benchmark impegnati citati nell'articolo + test
paper/               # Articolo di ricerca + sezioni modulari
benchmarks/          # Script driver per benchmark
experiments/         # Esecuzioni di esperimenti esplorativi

# Utilizzo e operazioni
examples/            # Demo minime eseguibili (una per percorso di esecuzione)
demos/               # Walkthrough dimostrativi più grandi (BusyBox, Alpine, compilatore)
scripts/             # Punti di ingresso + automazione manutentori
tools/               # Strumenti per sviluppatori
training/            # Pipeline di addestramento
packaging/           # Scaffolding per distribuzione (Homebrew, Modal, DEPLOYMENT.md)

# Test, documenti, asset
tests/               # Suite di test (vedi tests/README.md)
docs/                # Documentazione
assets/              # Loghi / asset statici

# Output di build e runtime (gitignorati — rigenerabili, non impegnati)
checkpoints/         # Checkpoint pesanti .pt
training_results/    # Sweep di scalabilità coprocessore, studi di ablazione
dist/                # Distribuzioni di build
logs/  outputs/      # Log di esecuzione e output temporanei

Ogni directory di primo livello ha il proprio README.md che ne descrive lo scopo.

Test

python -m ncpu doctor
pytest tests/ -q   # 2.500+ test in tutto lo stack

La copertura spazia dalla verifica formale esaustiva dell'ALU, alle operazioni neurali, a neurOS, alla modalità compute, all'esecuzione multi-processo, MUXLEQ, BusyBox/Alpine, al toolkit di debug GPU, al coprocessore, alla sintesi Mog, all'esecuzione differenziabile, alla crittografia a tempo costante, ai programmi auto-modificanti, al compilatore diff, alla distribuzione multi-GPU, SOME e ai modelli predittivi JEPA.

Documentazione

• Articolo di ricerca — l'analisi completa e i risultati
• Articolo sul toolkit di debug GPU — il debugger nativo GPU a 26 comandi
• Riferimento toolkit di debug GPU — riferimento comandi
• Kernel Rust Metal — architettura, design a copia zero, istruzioni di build
• Pipeline di compilazione — flusso end-to-end da C a GPU
• CPU neurale JEPA — architettura computer neurale bottom-up
• Modello del mondo JEPA — design delle dinamiche predittive
• Indice dei modelli — inventario completo dei modelli addestrati
• Guida completa SOME — controller nascosto e pipeline di addestramento
• Programmi differenziabili — ottimizzazione programmi, sintesi, scoperta ISA
• Risultati benchmark — numeri pass@1 per ogni modalità e livello di modello

Licenza

MIT