Runtime de recherche pour ordinateurs neuronaux différentiables, émulation de CPU basée sur GPU et synthèse de programmes. Comprend une ALU neuronale, de la cryptographie à temps constant, des modèles du monde JEPA et un compilateur C auto-hébergé sur Metal.
Un ordinateur complet dont chaque couche — arithmétique, OS, compilateur, affichage — est soit un réseau neuronal entraîné, soit s'exécute entièrement sur GPU.
Le modèle ne s'exécute pas sur l'ordinateur. Le modèle est l'ordinateur.
nCPU est un seul dépôt qui poursuit une seule thèse dans cinq directions : un ordinateur peut être construit à partir de composants appris, et une fois que toute la pile d'exécution est différentiable, les programmes cessent d'être des choses que l'on écrit pour devenir des choses que l'on peut rechercher par descente de gradient. Chaque sous-système ci-dessous repose sur ses propres mesures ; ensemble, ils couvrent la pile, des opérations ALU individuelles à un système d'exploitation, jusqu'à la synthèse de programmes.
Chaque opération ALU — addition, soustraction, multiplication, logique binaire, décalages, division — est un réseau neuronal entraîné. Le système d'exploitation neuronal (neurOS) gère la mémoire, planifie les processus et compile le code via 11 modèles entraînés, sans recours à des implémentations écrites à la main. Un affichage neuronal génère les caractères via des MLP char→glyphe et un ConvNet (143 K paramètres). L'ensemble du pipeline — code source → compilateur neuronal → assembleur neuronal → CPU neuronal → affichage neuronal — est différentiable de bout en bout.
L'ALU neuronale atteint 100 % de précision sur les entiers 32 bits, vérifiée exhaustivement pour toutes les entrées possibles. Un résultat inverse la hiérarchie matérielle conventionnelle : la multiplication est ici 12 fois plus rapide que l'addition, car l'addition nécessite une chaîne de retenue en 8 passes, alors que la multiplication se décompose en consultations parallèles de tables de paires d'octets.
| Instruction | Stratégie | Latence |
|---|---|---|
| ADD/SUB/CMP | Anticipation de retenue Kogge-Stone (8 passes) | 248 µs |
| MUL | LUT par paires d'octets (65 536 entrées) | 21 µs |
| AND/OR/XOR | Table de vérité vectorisée | 21 µs |
| SHL/SHR | Routage de bits par attention | 434 µs |
| DIV | Division par restauration (soustraction neuronale) | variable |
Précision des composants neurOS :
| Composant | Précision | Composant | Précision |
|---|---|---|---|
| MMU | 100 % | Génération de code assembleur | 100 % |
| TLB | 99,6 % | Tokenizer assembleur | 99,4 % |
| Cache | 99,7 % | Optimiseur du compilateur | 95,2 % |
| Ordonnanceur | 99,2 % | Chien de garde | 100 % |
| Préchargement | 97,8 % | Allocateur de blocs | 98,4 % |
Un ordinateur autonome sur un seul GPU — le CPU n'intervient qu'au démarrage. Le noyau Rust + Metal exécute environ 200 instructions ARM64 (entières et flottantes) à environ 1,9 M d'instructions par seconde, avec mémoire partagée sans copie (zero-copy) et une variance nulle du nombre de cycles entre exécutions (σ = 0,0).
Ce qui s'y exécute :
nSynth est un système de synthèse de programmes basé sur Rust qui découvre des programmes exécutables à partir d'exemples d'entrée/sortie en utilisant la descente de gradient, l'énumération et la recherche. Combiné à un moteur ML/tensoriel complet et à une pile web complète, il permet la synthèse de :
Couverture : 420/420 problèmes de synthèse (Mog : 315/315, nSynth : 105/105)
Trois piliers :
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]
L'ALU neuronale injectée dans le passage avant d'un transformer en tant qu'expert routé. Une porte apprise par token décide si chaque token passe par le MLP original ou par l'ALU neuronale. Des tables de vérité douces bilinéaires fournissent une logique différentiable, des opérations tensorieles fournissent une arithmétique différentiable, et le routage est modulé par la confiance du modèle.
Résultats d'une campagne de 11 modèles sur les familles Qwen 2.5/3/3.5, sur des tâches arithmétiques :
| Modèle | Précision arithmétique | Note |
|---|---|---|
| Qwen3.5-2B (instruct) | 14,5 % → 71,0 % (+56,5 pp) | meilleur global |
| Qwen3.5-2B (base) | 15,5 % → 63,0 % (+47,5 pp) | 100 % sur ADD/SUB/MUL/DIV |
| Qwen3.5-4B | +51,0 pp | plus grand gain pour un modèle de base (ex æquo) |
| Qwen3.5-9B | +51,0 pp | plus grand gain pour un modèle de base (ex æquo) |
Le transfert réel est mesuré, pas extrapolé : sur HumanEval complet (Qwen3.5-4B, A100), 62,2 % → 64,6 % — quatre problèmes supplémentaires résolus.
Un modèle de monde prédictif de l'ordinateur lui-même. Parallèlement à l'exécution exacte, un réseau de type JEPA (Joint Embedding Predictive Architecture) apprend à prédire les transitions d'état de la machine dans un espace latent compressé :
latent_state_t + instruction → prédicteur → latent_state_{t+1}
Il fonctionne à deux niveaux. Une démo Python (ncpu/jepa_neural_cpu/) exécute de vrais programmes à côté du prédicteur, transformant l'erreur de prédiction en un signal d'anomalie en direct. Une implémentation Rust Metal (kernels/rust_metal/src/jepa/, 2 858 lignes) observe l'exécution déterministe du GPU et oriente activement l'ordonnancement via des surcharges de biais apprises.
Parce que le substrat sous-jacent est exact, ce modèle de monde possède deux propriétés que la plupart n'ont pas : une vérité de terrain gratuite illimitée (exécuter plus de programmes), et la possibilité de mélanger à volonté l'exécution prédite et l'exécution exacte — spéculation latente bon marché en exploration, exécution exacte quand c'est important. La direction à long terme est une hiérarchie de prédicteurs aux niveaux du bit, de l'instruction, du programme et de la tâche.
python3 -m ncpu.jepa_neural_cpu.demo # démo de l'ordinateur neuronal JEPA ascendant
python -m ncpu.world_model.quickstart # démarrage rapide du modèle de monde JEPA
pip install -e ".[demo,dev]"
# La démo phare : le GPU comme ordinateur complet (macOS / Apple Silicon)
python -m ncpu gpu # démarrage
python -m ncpu gpu --neural-alu # avec l'ALU neuronale intégrée au shader Metal
python -m ncpu gpu debug # débogueur déterministe à 26 commandes
# Multi-plateforme, sans dépendances lourdes
python -m ncpu discover # programme par exemples, via synthèse différentiable
python -m ncpu text --interactive # machine de texte / chiffrement neuronale
# Pipeline neuronal complet (nécessite la pile de modèles)
python -m ncpu full-neural # CPU neuronal ascendant + affichage neuronal
python -m ncpu meta-compare # démo de comparaison côte à côte
# Couche prédictive JEPA
python3 -m ncpu.jepa_neural_cpu.demo
python -m ncpu.world_model.quickstart
# Rust natif, sans Python requis
cd kernels/rust_metal
cargo run --bin ncpu_run -- --elf ../../demos/gpu/busybox.elf --rootfs -- echo hello
| Mode | Ce qui s'exécute | Différentiable ? | Vitesse |
|---|---|---|---|
| Neural | 13 modèles .pt entraînés | oui — flux de gradient complet | ~5K IPS |
| Rapide | opérations tensorieles natives | oui — autograd standard | ~5K IPS |
| Compute | Shader Rust + Metal | non (matériel discret) | ~1,9M IPS |
Les trois exécutent les mêmes programmes et produisent les mêmes résultats. Le mode neural envoie chaque opération via des réseaux entraînés. Le mode rapide utilise des tenseurs natifs avec le même ISA et la même différentiabilité. Le mode Compute échange le flux de gradient contre la vitesse — c'est là que l'OS UNIX démarre, que le compilateur s'auto-héberge et que BusyBox s'exécute.
# Mode neural — chaque opération est un modèle entraîné
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 — calculé par la LUT neuronale de paires d'octets
# Coprocesseur différentiable — injection dans n'importe quel modèle Hugging Face
from ncpu.coprocessor import inject_ncpu_coprocessor, NCPUCoprocessorConfig
config = NCPUCoprocessorConfig(confidence_aware=True, deterministic_alu=True)
inject_ncpu_coprocessor(model, config)
# Synthèse de programme différentiable
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)
# découvre : ADD R2, R0, R1; HALT
# Modèle de monde JEPA — prédire les transitions d'état de la machine
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))
| Couche | Implémentation | Résultat |
|---|---|---|
| ALU | 13 modèles .pt entraînés | Arithmétique entière exacte sur 32 bits, vérifiée exhaustivement |
| OS | neurOS — 11 modèles neuronaux, aucun repli | MMU, TLB, cache, ordonnanceur, compilateur appris |
| Compute GPU | Noyau Rust Metal, ~200 instructions ARM64 | Programmes arbitraires à ~1,9M IPS |
| OS UNIX | C compilé sur Metal | fork/pipe/wait, shell à 25 commandes, 28 appels système |
| Compilateur | cc.c, ~4 200 lignes, auto-hébergé | Se compile lui-même, puis compile des programmes — sur GPU |
| Chargeur ELF | Vrais binaires Linux sur GPU | BusyBox et Alpine Linux v3.20 sur Metal |
| Coprocesseur | ALU neuronale dans un passage avant de transformer | Tokens routés via l'arithmétique neuronale, gains mesurés |
| JEPA | Modèle de monde prédictif de la dynamique de la machine | Spéculation latente + détection d'anomalies sur un substrat exact |
| Synthèse de programmes | Rétropropagation à travers l'exécution | Programmes découverts à partir d'exemples E/S |
| Crypto temps constant | AES-128 ECB/CBC (ncpu/crypto/) | σ = 0.0 en timing ; vecteurs de test FIPS 197 + NIST SP 800-38A passés |
| Multi-GPU | Cœurs distribués avec mémoire partagée | fork/pipe/wait entre GPU ; exécution parallèle et en pipeline |
| SOME | Contrôleur caché avec têtes latentes | Inférence auto-optimisante ; gains sur HumanEval+ et BigCodeBench |
L'exécution sur GPU produit ici une variance nulle du nombre de cycles — σ = 0.0 sur 270 exécutions, alors que le même code sur Apple Silicon natif montre une variance temporelle de 47 à 73 %. Sans cache de données, il n'y a pas de lignes de cache ni de pénalité de défaut de cache, donc les attaques par tables T d'AES n'ont rien à mesurer.
Sur cette propriété, ncpu/crypto/ fournit un AES-128 à temps constant (ECB et CBC) à partir de 19 primitives à temps constant, passant tous les vecteurs de test FIPS 197 et NIST SP 800-38A.
Un contrôleur caché qui transforme une partie de la machine neuronale en coprocesseur interne pour la génération de code : une boucle mise en mémoire tampon « penser → écrire → vérifier → corriger → valider », des têtes d'action, d'arrêt, de descripteur, de correction d'état et de mémoire apprises, et des poids rapides locaux à chaque tâche mis à jour pendant l'inférence. La tête de mémoire apprise a amélioré l'erreur quadratique moyenne de validation de 83,26 % par rapport à la baseline.
Mesuré de bout en bout : HumanEval+ pour qwen3.5:4b est passé de 147 à 154, et pour qwen3.5:9b de 144 à 156 ; BigCodeBench-Hard pour qwen3.5:9b est passé de 33 à 49.
SUBLEQ plus MUX, exécuté dans les trois modes d'exécution. En mode neuronal, SUB passe par l'anticipation de retenue Kogge-Stone (~248 µs) et MUX par AND/OR/NOT neuronaux (~63 µs). Il charge les images .dec et démarre eForth. Le point clé : si des réseaux entraînés exécutent exactement un ordinateur à deux instructions et un seul jeu d'instructions, la construction s'étend à n'importe quel jeu d'instructions.
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
ncpu/
differentiable/ # Exécution différentiable, synthèse de programme, découverte d'ISA
coprocessor/ # Injection de nCPU dans les passages avant de transformers
execution_training/# Exécution différentiable comme signal d'entraînement pour les modèles de langage de code
crypto/ # Crypto à temps constant (AES-128)
distributed/ # Exécution distribuée multi-GPU
jepa_neural_cpu/ # Démo d'ordinateur neuronal JEPA ascendant
world_model/ # Modèle de monde JEPA (dynamique prédictive)
autoresearch/ # Recherche automatisée + boucle NPCoT composée
os/
neuros/ # OS neuronal : 17 modules (MMU, TLB, cache, ordonnanceur...)
gpu/ # OS UNIX sur GPU : shell, système de fichiers, chargeur ELF, source C
self_optimizing/ # SOME : contrôleur caché, poids rapides
neural/ # NeuralCPU : pont pour ALU neuronale, pipeline de tissage
model/ # CPU basé sur modèle (neural_ops, assembleur)
tensor/ # Émulateur tensoriel ARM64 (différentiable)
# Backends compilés / accélérés
kernels/ # rust_metal (noyau Rust+Metal ARM64), mlx, npcot_wasm
nsynth/ # Moteur de synthèse universel : gradient + énumératif + recherche + ML + web
# Couverture de synthèse 420/420, 1000+ API ML, 500+ API web
# Cœur : synthèse de programme (105/105), ML/tensoriel (18+ modules), web (19+ modules)
# ML universel : attention, diffusion, flows, ODE, NeRF, RL, méta-apprentissage
# Web complet : WASM, WebGPU, frameworks, API, styles, bundling
packages/ # Paquets compagnons (metal_mlp)
# Modèles et corpus de synthèse
models/ # Poids des composants neuronaux entraînés (voir models/MODEL_INDEX.md)
programs/ # Corpus de référence de synthèse (arithmétique, binaire, algorithmes, ...)
# Preuves, article, expériences
artifacts/ # Résultats de référence validés cités par l'article + tests
paper/ # Article de recherche + sections modulaires
benchmarks/ # Scripts de pilotage des benchmarks
experiments/ # Exécutions d'expériences exploratoires
# Utilisation et opérations
examples/ # Démonstrations minimales exécutables (une par chemin d'exécution)
demos/ # Démonstrations plus grandes (BusyBox, Alpine, compilateur)
scripts/ # Points d'entrée + automatisation pour mainteneurs
tools/ # Outils développeur
training/ # Pipelines d'entraînement
packaging/ # Échafaudage de déploiement (Homebrew, Modal, DEPLOYMENT.md)
# Tests, docs, assets
tests/ # Suite de tests (voir tests/README.md)
docs/ # Documentation
assets/ # Logos / ressources statiques
# Sortie de construction et d'exécution (gitignoré — régénérable, non validé)
checkpoints/ # Grands points de contrôle de poids .pt
training_results/ # Analyses de scale du coprocesseur, études d'ablation
dist/ # Distributions de construction
logs/ outputs/ # Journaux d'exécution et sorties temporaires
Chaque répertoire de premier niveau a son propre README.md décrivant son but.
python -m ncpu doctor
pytest tests/ -q # 2 500+ tests sur toute la pile
La couverture inclut la vérification formelle exhaustive de l'ALU, les opérations neuronales, neurOS, le mode compute, l'exécution multi-processus, MUXLEQ, BusyBox/Alpine, la boîte à outils de débogage GPU, le coprocesseur, la synthèse Mog, l'exécution différentiable, la crypto à temps constant, les programmes auto-modifiants, le compilateur diff, la distribution multi-GPU, SOME, et les modèles prédictifs JEPA.
MIT