nCPU

एक पूरा कंप्यूटर जिसमें प्रत्येक परत — अंकगणित, OS, कंपाइलर, प्रदर्शन — या तो प्रशिक्षित तंत्रिका नेटवर्क है या पूरी तरह से GPU पर चलता है।
मॉडल कंप्यूटर पर नहीं चलता। मॉडल ही कंप्यूटर है।

nCPU एक ऐसा रिपॉजिटरी है जो एक ही थीसिस को पाँच दिशाओं से आगे बढ़ाता है: एक कंप्यूटर को सीखे गए घटकों से बनाया जा सकता है, और जब पूरा निष्पादन स्टैक डिफरेंशिएबल हो जाता है, तो प्रोग्राम वे चीज़ें नहीं रह जाते जो आप लिखते हैं, बल्कि वे चीज़ें बन जाते हैं जिन्हें आप ग्रेडिएंट डिसेंट द्वारा खोज सकते हैं। नीचे प्रत्येक उप-प्रणाली अपने स्वयं के माप के आधार पर खड़ी है; साथ में वे ALU संचालन से लेकर ऑपरेटिंग सिस्टम से प्रोग्राम संश्लेषण तक पूरे स्टैक को कवर करते हैं।

पाँच उप-प्रणालियाँ

1. तंत्रिका कंप्यूटर

प्रत्येक ALU संचालन — जोड़, घटाव, गुणा, बिटवाइज लॉजिक, शिफ्ट, विभाजन — एक प्रशिक्षित तंत्रिका नेटवर्क है। तंत्रिका OS (neurOS) मेमोरी प्रबंधित करता है, प्रक्रियाओं को शेड्यूल करता है, और 11 प्रशिक्षित मॉडलों के माध्यम से कोड संकलित करता है, जिसमें कोई हाथ से लिखा गया फ़ॉलबैक नहीं है। एक तंत्रिका प्रदर्शन char→glyph MLPs और एक ConvNet (143K पैरामीटर) के माध्यम से वर्ण रेंडर करता है। पूरी पाइपलाइन — स्रोत कोड → तंत्रिका कंपाइलर → तंत्रिका असेंबलर → तंत्रिका CPU → तंत्रिका प्रदर्शन — अंत से अंत तक डिफरेंशिएबल है।

तंत्रिका ALU 32-बिट पूर्णांक अंकगणित पर 100% सटीकता प्राप्त करता है, हर संभव इनपुट पर विस्तार से सत्यापित किया गया है। एक परिणाम पारंपरिक हार्डवेयर पदानुक्रम को उलट देता है: गुणा यहाँ जोड़ की तुलना में 12x तेज़ है, क्योंकि जोड़ को 8-पास कैरी चेन की आवश्यकता होती है जबकि गुणा समानांतर बाइट-जोड़ी तालिका लुकअप में विघटित हो जाता है।

neurOS घटक सटीकता:

2. GPU कंप्यूटर

एक एकल GPU पर आत्मनिर्भर कंप्यूटर — CPU केवल बूटस्ट्रैप पर शामिल होता है। Rust + Metal कर्नेल लगभग 200 ARM64 निर्देश (पूर्णांक और फ्लोटिंग-पॉइंट) लगभग 1.9M निर्देश प्रति सेकंड पर निष्पादित करता है, जिसमें जीरो-कॉपी शेयर्ड मेमोरी और रनों में जीरो साइकिल-काउंट भिन्नता (σ = 0.0) है।

इस पर क्या चलता है:

• एक मल्टी-प्रोसेस UNIX OS: fork/pipe/wait, 25-कमांड शेल, 28 सिस्कॉल, 15 तक समवर्ती प्रक्रियाएँ
• एक सेल्फ-होस्टिंग C कंपाइलर (~4,200 पंक्तियाँ) जो स्वयं को संकलित करता है, फिर अन्य प्रोग्राम संकलित करता है और चलाता है — पूरी तरह से GPU पर
• वास्तविक Linux बाइनरी एक ELF64 लोडर के माध्यम से: BusyBox (264KB, 34+ कमांड) और Alpine Linux v3.20
• 13+ संकलित C एप्लिकेशन: SHA-256, AES-128, Tetris, Snake, एक Brainfuck इंटरप्रेटर, एक Forth REPL, एक CHIP-8 एमुलेटर, एक HTTP सर्वर, एक MNIST क्लासिफायर, और अन्य
• एक 26-कमांड डिटर्मिनिस्टिक डिबगर: निर्देश अनुरेखण, ब्रेकपॉइंट और वॉचपॉइंट, टाइम-ट्रैवल डिबगिंग, एक मेमोरी सैनिटाइज़र, स्वचालित फ़ज़िंग, रिवर्स डेटा-फ़्लो विश्लेषण, और कॉन्स्टेंट-टाइम सत्यापन। डिटर्मिनिस्टिक निष्पादन ही टाइम-ट्रैवल और सटीक रीप्ले को संभव बनाता है; पारंपरिक CPUs, कैश- और अटकल-प्रेरित समय शोर के साथ, समान गारंटी नहीं दे सकते।

3. nSynth: सार्वभौमिक संश्लेषण इंजन

nSynth एक Rust-आधारित प्रोग्राम संश्लेषण प्रणाली है जो इनपुट/आउटपुट उदाहरणों से निष्पादन योग्य प्रोग्राम खोजती है, ग्रेडिएंट डिसेंट, गणना और खोज का उपयोग करके। एक व्यापक ML/टेंसर इंजन और पूर्ण वेब स्टैक के साथ मिलकर, यह निम्नलिखित के संश्लेषण को सक्षम बनाता है:

• एल्गोरिदम: अंकगणित, बिटवाइज, डेटा संरचनाएँ, एल्गोरिदम
• ML मॉडल: CNNs, RNNs, Transformers, GNNs, Diffusion, Flows, RL एजेंट
• वेब ऐप्स: फुल-स्टैक React/Next.js, APIs, स्टाइलिंग, WebGL, WASM एप्लिकेशन

कवरेज: 420/420 संश्लेषण समस्याएँ (Mog: 315/315, nSynth: 105/105)

तीन स्तंभ:

1. प्रोग्राम संश्लेषण (कोर): ग्रेडिएंट-आधारित खोज, गणनात्मक संश्लेषण, टेम्पलेट मिलान, और खोज परिवारों के माध्यम से 105/105 समस्याएँ हल
2. ML/टेंसर इंजन (1000+ APIs): स्वचालित विभेदन के साथ व्यापक टेंसर संचालन, किसी भी ML आर्किटेक्चर के संश्लेषण को सक्षम करना:
   • ध्यान तंत्र (MultiHeadAttention, RoPE, ALiBi, FlashAttention, Linformer, Performer)
   • जनरेटिव मॉडल (Diffusion DDPM/DDIM, Normalizing Flows RealNVP/MAF, Neural ODE)
   • विज़न (3D Conv, Deformable Conv, Fourier Features, NeRF वॉल्यूम रेंडरिंग)
   • RL (Policy Gradients, PPO, A3C, Experience Replay, GAE, Value Functions)
   • मेटा-लर्निंग (MAML, Reptile, DARTS, ENAS NAS)
   • संभाव्य ML (Bayesian NN, MC Dropout, Variational Inference, KL Divergence)
   • दक्षता (Pruning, Quantization, Knowledge Distillation, Distributed Training)
3. वेब स्टैक (500+ APIs): पूर्ण-स्टैक वेब संश्लेषण पूर्ण कवरेज के साथ:
   • कोर: HTTP, WebSocket, SSL, JSON, Cookies, Forms, Middleware
   • फ्रेमवर्क: React, Vue, Svelte, Solid, Next.js, Remix
   • आधुनिक: WASM, WebGPU, WebAuthn, WebRTC, PWA
   • APIs: GraphQL, gRPC, tRPC, OpenAPI
   • स्टाइलिंग: CSS, Tailwind, रिस्पॉन्सिव, डार्क मोड
   • बंडलिंग: 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. डिफरेंशिएबल कोप्रोसेसर

तंत्रिका ALU को एक ट्रांसफॉर्मर के फॉरवर्ड पास में एक रूटेड विशेषज्ञ के रूप में इंजेक्ट किया गया। एक सीखा हुआ प्रति-टोकन गेट तय करता है कि प्रत्येक टोकन मूल MLP से गुजरेगा या तंत्रिका ALU से। बिलिनियर सॉफ्ट सत्य तालिकाएँ डिफरेंशिएबल लॉजिक प्रदान करती हैं, टेंसर ऑप्स डिफरेंशिएबल अंकगणित प्रदान करते हैं, और गेटिंग मॉडल आत्मविश्वास द्वारा मॉड्यूलेट की जाती है।

Qwen 2.5/3/3.5 परिवारों में 11 मॉडल स्वीप के परिणाम, अंकगणितीय कार्यों पर:

वास्तविक दुनिया का स्थानांतरण मापा जाता है, अनुमानित नहीं: पूर्ण HumanEval पर (Qwen3.5-4B, A100), 62.2% → 64.6% — चार अतिरिक्त समस्याएँ हल।

5. JEPA पूर्वानुमानित मशीन गतिकी

कंप्यूटर का ही एक पूर्वानुमानित विश्व मॉडल। सटीक निष्पादन के साथ, एक JEPA-शैली नेटवर्क (Joint Embedding Predictive Architecture) एक संपीड़ित अव्यक्त स्थान में मशीन स्थिति संक्रमणों की भविष्यवाणी करना सीखता है:

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

यह दो स्तरों पर चलता है। एक Python डेमो (ncpu/jepa_neural_cpu/) भविष्यवक्ता के बगल में वास्तविक प्रोग्राम निष्पादित करता है, पूर्वानुमान त्रुटि को एक लाइव विसंगति संकेत में बदलता है। एक Rust Metal कार्यान्वयन (kernels/rust_metal/src/jepa/, 2,858 पंक्तियाँ) डिटर्मिनिस्टिक GPU निष्पादन का अवलोकन करता है और सीखे गए पूर्वाग्रह ओवरराइड के माध्यम से शेड्यूलिंग को सक्रिय रूप से संचालित करता है।

क्योंकि नीचे का आधार सटीक है, इस विश्व मॉडल में दो गुण हैं जो अधिकांश में नहीं हैं: असीमित मुफ्त ग्राउंड ट्रुथ (अधिक प्रोग्राम चलाएँ), और इच्छानुसार पूर्वानुमानित और सटीक निष्पादन को मिश्रित करने की क्षमता — खोज करते समय सस्ती अव्यक्त अटकल, जब मायने रखता है तब सटीक निष्पादन। दीर्घकालिक दिशा बिट, निर्देश, प्रोग्राम और कार्य स्तरों पर भविष्यवक्ताओं का एक पदानुक्रम है।

python3 -m ncpu.jepa_neural_cpu.demo     # नीचे-ऊपर JEPA तंत्रिका कंप्यूटर डेमो
python -m ncpu.world_model.quickstart    # JEPA मशीन विश्व मॉडल त्वरित प्रारंभ

60 सेकंड में प्रारंभ करें

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

# शीर्षक डेमो: GPU एक पूर्ण कंप्यूटर के रूप में (macOS / Apple Silicon)
python -m ncpu gpu                 # बूट करें
python -m ncpu gpu --neural-alu    # तंत्रिका ALU Metal शेडर के अंदर
python -m ncpu gpu debug           # 26-कमांड डिटर्मिनिस्टिक डिबगर

# क्रॉस-प्लेटफ़ॉर्म, कोई भारी निर्भरता नहीं
python -m ncpu discover            # उदाहरणों द्वारा प्रोग्राम, डिफरेंशिएबल संश्लेषण के माध्यम से
python -m ncpu text --interactive  # तंत्रिका पाठ / सिफर मशीन

# पूर्ण तंत्रिका पाइपलाइन (मॉडल स्टैक की आवश्यकता है)
python -m ncpu full-neural         # नीचे-ऊपर तंत्रिका CPU + तंत्रिका प्रदर्शन
python -m ncpu meta-compare        # साथ-साथ तुलना डेमो

# JEPA पूर्वानुमान परत
python3 -m ncpu.jepa_neural_cpu.demo
python -m ncpu.world_model.quickstart

# Rust-मूल, Python की आवश्यकता नहीं
cd kernels/rust_metal
cargo run --bin ncpu_run -- --elf ../../demos/gpu/busybox.elf --rootfs -- echo hello

तीन निष्पादन मोड

तीनों समान प्रोग्राम निष्पादित करते हैं और समान परिणाम उत्पन्न करते हैं। तंत्रिका मोड प्रत्येक संचालन को प्रशिक्षित नेटवर्क के माध्यम से भेजता है। तेज़ मोड समान ISA और समान डिफरेंशिएबिलिटी के साथ मूल टेंसर का उपयोग करता है। गणना मोड गति के लिए ग्रेडिएंट प्रवाह का आदान-प्रदान करता है — यह वह जगह है जहाँ UNIX OS बूट होता है, कंपाइलर सेल्फ-होस्ट होता है, और BusyBox चलता है।

# तंत्रिका मोड — प्रत्येक संचालन एक प्रशिक्षित मॉडल है
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 — तंत्रिका बाइट-जोड़ी LUT द्वारा गणना

# डिफरेंशिएबल कोप्रोसेसर — किसी भी Hugging Face मॉडल में इंजेक्ट करें
from ncpu.coprocessor import inject_ncpu_coprocessor, NCPUCoprocessorConfig
config = NCPUCoprocessorConfig(confidence_aware=True, deterministic_alu=True)
inject_ncpu_coprocessor(model, config)

# डिफरेंशिएबल प्रोग्राम संश्लेषण
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)
# खोजता है: ADD R2, R0, R1; HALT

# JEPA विश्व मॉडल — मशीन स्थिति संक्रमणों की भविष्यवाणी करें
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))

पूरा स्टैक

समय साइड-चैनल प्रतिरक्षा

यहाँ GPU निष्पादन शून्य साइकिल-काउंट भिन्नता उत्पन्न करता है — 270 रनों में σ = 0.0, जबकि मूल Apple Silicon पर समान कोड 47–73% समय भिन्नता दिखाता है। कोई डेटा कैश न होने के कारण कोई कैश लाइनें नहीं हैं और कोई कैश-मिस दंड नहीं है, इसलिए AES T-टेबल हमलों के पास मापने के लिए कुछ नहीं है।

इस गुण पर निर्मित, ncpu/crypto/ 19 कॉन्स्टेंट-टाइम प्रिमिटिव से कॉन्स्टेंट-टाइम AES-128 (ECB और CBC) प्रदान करता है, जो सभी FIPS 197 और NIST SP 800-38A परीक्षण वेक्टर पास करता है।

स्व-अनुकूलन मशीन इंजन (SOME)

एक छिपा नियंत्रक जो तंत्रिका मशीन के हिस्से को कोड उत्पादन के लिए आंतरिक कोप्रोसेसर में बदल देता है: एक बफर्ड think → write → verify → patch → commit लूप, सीखे गए action/halt/descriptor/state-patch/memory शीर्ष, और अनुमान के दौरान अद्यतन किए गए कार्य-स्थानीय तेज़ वजन। सीखा गया मेमोरी शीर्ष बेसलाइन की तुलना में सत्यापन MSE में 83.26% सुधार करता है।

अंत से अंत तक मापा गया: qwen3.5:4b के लिए HumanEval+ 147 → 154 और qwen3.5:9b के लिए 144 → 156; qwen3.5:9b के लिए BigCodeBench-Hard 33 → 49 में सुधार हुआ।

MUXLEQ: दो निर्देशों में ट्यूरिंग-पूर्ण

SUBLEQ प्लस MUX, तीनों निष्पादन मोड में चलता है। तंत्रिका मोड में, SUB Kogge-Stone carry-lookahead (~248 µs) से गुजरता है और MUX तंत्रिका AND/OR/NOT (~63 µs) से गुजरता है। यह .dec इमेज लोड करता है और eForth बूट करता है। मुद्दा: यदि प्रशिक्षित नेटवर्क एक दो-निर्देश एक-निर्देश-सेट कंप्यूटर को सटीक रूप से निष्पादित करते हैं, तो निर्माण किसी भी निर्देश सेट तक फैलता है।

उदाहरणों से प्रोग्राम संश्लेषण (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

परियोजना संरचना

ncpu/
  differentiable/    # डिफरेंशिएबल निष्पादन, प्रोग्राम संश्लेषण, ISA खोज
  coprocessor/       # nCPU को ट्रांसफॉर्मर फॉरवर्ड पास में इंजेक्ट करें
  execution_training/# कोड LM के लिए डिफरेंशिएबल निष्पादन प्रशिक्षण संकेत के रूप में
  crypto/            # कॉन्स्टेंट-टाइम क्रिप्टो (AES-128)
  distributed/       # मल्टी- GPU वितरित निष्पादन
  jepa_neural_cpu/   # नीचे-ऊपर JEPA तंत्रिका कंप्यूटर डेमो
  world_model/       # JEPA मशीन विश्व मॉडल (पूर्वानुमानित गतिकी)
  autoresearch/      # स्वचालित अनुसंधान + यौगिक NPCoT लूप
  os/
    neuros/          # तंत्रिका OS: 17 मॉड्यूल (MMU, TLB, कैश, शेड्यूलर...)
    gpu/             # GPU UNIX OS: शेल, फ़ाइल सिस्टम, ELF लोडर, C स्रोत
  self_optimizing/   # SOME: छिपा नियंत्रक, तेज़ वजन
  neural/            # NeuralCPU: तंत्रिका ALU ब्रिज, वीव पाइपलाइन
  model/             # मॉडल-आधारित CPU (neural_ops, असेंबलर)
  tensor/            # टेंसर-आधारित ARM64 एमुलेटर (डिफरेंशिएबल)

# संकलित / त्वरित बैकएंड
kernels/             # rust_metal (Rust+Metal ARM64 कर्नेल), mlx, npcot_wasm
nsynth/              # सार्वभौमिक संश्लेषण इंजन: ग्रेडिएंट + गणनात्मक + खोज + ML + वेब
                     # 420/420 संश्लेषण कवरेज, 1000+ ML APIs, 500+ वेब APIs
                     # कोर: प्रोग्राम संश्लेषण (105/105), ML/टेंसर (18+ मॉड्यूल), वेब (19+ मॉड्यूल)
                     # सार्वभौमिक ML: ध्यान, प्रसार, प्रवाह, ODE, NeRF, RL, मेटा-लर्निंग
                     # पूर्ण वेब: WASM, WebGPU, फ्रेमवर्क, APIs, स्टाइलिंग, बंडलिंग
packages/            # साथी पैकेज (metal_mlp)

# मॉडल और संश्लेषण कोष
models/              # प्रशिक्षित तंत्रिका-घटक वजन (models/MODEL_INDEX.md देखें)
programs/            # संश्लेषण बेंचमार्क कोष (अंकगणित, बिटवाइज, एल्गोरिदम, ...)

# साक्ष्य, पेपर, प्रयोग
artifacts/           # पेपर द्वारा उद्धृत प्रतिबद्ध बेंचमार्क परिणाम + परीक्षण
paper/               # अनुसंधान पेपर + मॉड्यूलर अनुभाग
benchmarks/          # बेंचमार्क ड्राइवर स्क्रिप्ट
experiments/         # खोजपूर्ण प्रयोग रन

# उपयोग और संचालन
examples/            # न्यूनतम चलने योग्य डेमो (प्रति निष्पादन पथ एक)
demos/               # बड़े शोकेस वॉकथ्रू (BusyBox, Alpine, कंपाइलर)
scripts/             # प्रवेश बिंदु + रखरखाव स्वचालन
tools/               # डेवलपर टूलिंग
training/            # प्रशिक्षण पाइपलाइन
packaging/           # तैनाती मचान (Homebrew, Modal, DEPLOYMENT.md)

# परीक्षण, दस्तावेज़, संपत्तियाँ
tests/               # परीक्षण सूट (tests/README.md देखें)
docs/                # दस्तावेज़ीकरण
assets/              # लोगो / स्थिर संपत्तियाँ

# निर्माण और रनटाइम आउटपुट (gitignored — पुनर्उत्पादनीय, प्रतिबद्ध नहीं)
checkpoints/         # बड़े .pt वजन चेकपॉइंट
training_results/    # कोप्रोसेसर स्केलिंग स्वीप, एब्लेशन अध्ययन
dist/                # निर्माण वितरण
logs/  outputs/      # रन लॉग और स्क्रैच आउटपुट

प्रत्येक शीर्ष-स्तरीय निर्देशिका का अपना README.md है जो इसके उद्देश्य का वर्णन करता है।

परीक्षण

python -m ncpu doctor
pytest tests/ -q   # 2,500+ परीक्षण पूरे स्टैक पर

कवरेज में ALU का विस्तृत औपचारिक सत्यापन, तंत्रिका ऑप्स, neurOS, गणना मोड, मल्टी-प्रोसेस निष्पादन, MUXLEQ, BusyBox/Alpine, GPU डिबगिंग टूलकिट, कोप्रोसेसर, Mog संश्लेषण, डिफरेंशिएबल निष्पादन, कॉन्स्टेंट-टाइम क्रिप्टो, स्व-संशोधित प्रोग्राम, डिफ कंपाइलर, मल्टी-GPU वितरण, SOME, और JEPA पूर्वानुमान मॉडल शामिल हैं।

दस्तावेज़ीकरण

• अनुसंधान पेपर — पूर्ण विश्लेषण और निष्कर्ष
• GPU डिबगिंग टूलकिट पेपर — 26-कमांड GPU-मूल डिबगर
• GPU डिबगिंग टूलकिट संदर्भ — कमांड संदर्भ
• Rust Metal कर्नेल — आर्किटेक्चर, जीरो-कॉपी डिज़ाइन, निर्माण निर्देश
• संकलन पाइपलाइन — अंत-से-अंत C-से-GPU प्रवाह
• JEPA तंत्रिका CPU — नीचे-ऊपर तंत्रिका कंप्यूटर आर्किटेक्चर
• JEPA मशीन विश्व मॉडल — पूर्वानुमानित गतिकी डिज़ाइन
• मॉडल सूची — पूर्ण प्रशिक्षित-मॉडल सूची
• SOME पूर्ण मार्गदर्शिका — छिपा नियंत्रक और प्रशिक्षण पाइपलाइन
• डिफरेंशिएबल प्रोग्राम — प्रोग्राम अनुकूलन, संश्लेषण, ISA खोज
• बेंचमार्क परिणाम — प्रत्येक मोड और मॉडल टियर के लिए pass@1 संख्याएँ

लाइसेंस

MIT