nCPU

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]

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

python3 -m ncpu.jepa_neural_cpu.demo     # 상향식 JEPA 신경망 컴퓨터 데모
python -m ncpu.world_model.quickstart    # JEPA 기계 세계 모델 퀵스타트

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

# 주요 데모: GPU를 완전한 컴퓨터로 (macOS / Apple Silicon)
python -m ncpu gpu                 # 부팅
python -m ncpu gpu --neural-alu    # Metal 셰이더 내부의 신경망 ALU 사용
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

# Neural 모드 — 모든 연산은 학습된 모델
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))

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/    # Differentiable execution, program synthesis, ISA discovery
  coprocessor/       # Inject nCPU into transformer forward passes
  execution_training/# Differentiable execution as training signal for code LMs
  crypto/            # Constant-time crypto (AES-128)
  distributed/       # Multi-GPU distributed execution
  jepa_neural_cpu/   # Bottom-up JEPA neural computer demo
  world_model/       # JEPA machine world model (predictive dynamics)
  autoresearch/      # Automated research + compounding NPCoT loop
  os/
    neuros/          # Neural OS: 17 modules (MMU, TLB, cache, scheduler...)
    gpu/             # GPU UNIX OS: shell, filesystem, ELF loader, C source
  self_optimizing/   # SOME: hidden controller, fast weights
  neural/            # NeuralCPU: neural ALU bridge, weave pipeline
  model/             # Model-based CPU (neural_ops, assembler)
  tensor/            # Tensor-based ARM64 emulator (differentiable)

# Compiled / accelerated backends
kernels/             # rust_metal (Rust+Metal ARM64 kernel), mlx, npcot_wasm
nsynth/              # Universal synthesis engine: gradient + enumerative + search + ML + web
                     # 420/420 synthesis coverage, 1000+ ML APIs, 500+ web APIs
                     # Core: program synthesis (105/105), ML/tensor (18+ modules), web (19+ modules)
                     # Universal ML: attention, diffusion, flows, ODEs, NeRF, RL, meta-learning
                     # Complete web: WASM, WebGPU, frameworks, APIs, styling, bundling
packages/            # Companion packages (metal_mlp)

# Models & synthesis corpus
models/              # Trained neural-component weights (see models/MODEL_INDEX.md)
programs/            # Synthesis benchmark corpus (arithmetic, bitwise, algorithms, ...)

# Evidence, paper, experiments
artifacts/           # Committed benchmark results cited by the paper + tests
paper/               # Research paper + modular sections
benchmarks/          # Benchmark driver scripts
experiments/         # Exploratory experiment runs

# Usage & ops
examples/            # Minimal runnable demos (one per execution path)
demos/               # Larger showcase walkthroughs (BusyBox, Alpine, compiler)
scripts/             # Entry points + maintainer automation
tools/               # Developer tooling
training/            # Training pipelines
packaging/           # Deployment scaffolding (Homebrew, Modal, DEPLOYMENT.md)

# Tests, docs, assets
tests/               # Test suite (see tests/README.md)
docs/                # Documentation
assets/              # Logos / static assets

# Build & runtime output (gitignored — regenerable, not committed)
checkpoints/         # Large .pt weight checkpoints
training_results/    # Coprocessor scaling sweeps, ablation studies
dist/                # Build distributions
logs/  outputs/      # Run logs and scratch outputs

python -m ncpu doctor
pytest tests/ -q   # 2,500개 이상의 스택 전반 테스트