nCPU

Um computador completo onde cada camada — aritmética, SO, compilador, tela — é uma rede neural treinada ou roda inteiramente na GPU.
O modelo não roda no computador. O modelo é o computador.

O nCPU é um repositório que persegue uma tese a partir de cinco direções: um computador pode ser construído a partir de componentes aprendidos, e quando toda a pilha de execução é diferenciável, programas deixam de ser coisas que você escreve e se tornam coisas que podem ser procuradas por gradiente descendente. Cada subsistema abaixo se sustenta por suas próprias medidas; juntos eles cobrem a pilha desde operações individuais da ALU até um sistema operacional e síntese de programas.

Os cinco subsistemas

1. O computador neural

Toda operação da ALU — adição, subtração, multiplicação, lógica bit a bit, deslocamentos, divisão — é uma rede neural treinada. O SO neural (neurOS) gerencia memória, escala processos e compila código através de 11 modelos treinados sem quedas para código escrito à mão. Uma tela neural renderiza caracteres através de MLPs char→glyph e uma ConvNet (143K parâmetros). O pipeline completo — código fonte → compilador neural → montador neural → CPU neural → tela neural — é diferenciável de ponta a ponta.

A ALU neural atinge 100% de precisão em aritmética de inteiros de 32 bits, verificada exaustivamente sobre todas as entradas possíveis. Um resultado inverte a hierarquia de hardware convencional: multiplicação é 12x mais rápida que adição aqui, porque adição precisa de uma cadeia de transporte de 8 passagens enquanto a multiplicação se decompõe em consultas paralelas de tabela de pares de bytes.

Precisão dos componentes do neurOS:

2. O computador GPU

Um computador autossuficiente em uma única GPU — a CPU é envolvida apenas no boot. O kernel Rust + Metal executa cerca de 200 instruções ARM64 (inteiros e ponto flutuante) a aproximadamente 1,9M instruções por segundo, com memória compartilhada de cópia zero e variância de contagem de ciclos zero entre execuções (σ = 0,0).

O que roda nele:

• Um SO UNIX multiprocesso: fork/pipe/wait, um shell de 25 comandos, 28 chamadas de sistema, até 15 processos concorrentes
• Um compilador C auto-hospedado (~4.200 linhas) que compila a si mesmo, depois compila e executa outros programas — inteiramente na GPU
• Binários reais do Linux via um carregador ELF64: BusyBox (264KB, 34+ comandos) e Alpine Linux v3.20
• 13+ aplicativos C compilados: SHA-256, AES-128, Tetris, Snake, um interpretador Brainfuck, um REPL Forth, um emulador CHIP-8, um servidor HTTP, um classificador MNIST e outros
• Um depurador determinístico de 26 comandos: rastreamento de instruções, pontos de interrupção e pontos de observação, depuração com viagem no tempo, sanitizador de memória, fuzzing automatizado, análise reversa de fluxo de dados e verificação de tempo constante. A execução determinística é o que torna possível a viagem no tempo e a repetição exata; CPUs convencionais, com ruído de temporização induzido por cache e especulação, não podem oferecer as mesmas garantias.

3. nSynth: Motor de síntese universal

nSynth é um sistema de síntese de programas baseado em Rust que descobre programas executáveis a partir de exemplos de entrada/saída usando gradiente descendente, enumeração e busca. Combinado com um motor ML/tensor abrangente e pilha web completa, permite a síntese de:

• Algoritmos: Aritmética, bit a bit, estruturas de dados, algoritmos
• Modelos de ML: CNNs, RNNs, Transformers, GNNs, Difusão, Flows, Agentes RL
• Aplicativos Web: Full-stack React/Next.js, APIs, estilização, WebGL, aplicações WASM

Cobertura: 420/420 problemas de síntese (Mog: 315/315, nSynth: 105/105)

Três Pilares:

1. Síntese de Programas (Núcleo): 105/105 problemas resolvidos via busca baseada em gradiente, síntese enumerativa, correspondência de padrões e famílias de busca
2. Motor ML/Tensor (1000+ APIs): Operações tensorais abrangentes com diferenciação automática, permitindo a síntese de QUALQUER arquitetura de ML:
   • Mecanismos de Atenção (MultiHeadAttention, RoPE, ALiBi, FlashAttention, Linformer, Performer)
   • Modelos Generativos (Difusão DDPM/DDIM, Normalizing Flows RealNVP/MAF, Neural ODE)
   • Visão (Conv 3D, Conv Deformável, Características de Fourier, Renderização de Volume NeRF)
   • RL (Policy Gradients, PPO, A3C, Experience Replay, GAE, Funções de Valor)
   • Meta-Aprendizado (MAML, Reptile, DARTS, ENAS NAS)
   • ML Probabilístico (Bayesian NN, MC Dropout, Inferência Variacional, Divergência KL)
   • Eficiência (Poda, Quantização, Destilação de Conhecimento, Treinamento Distribuído)
3. Pilha Web (500+ APIs): Síntese web full-stack com cobertura completa:
   • Núcleo: HTTP, WebSocket, SSL, JSON, Cookies, Formulários, Middleware
   • Frameworks: React, Vue, Svelte, Solid, Next.js, Remix
   • Moderno: WASM, WebGPU, WebAuthn, WebRTC, PWA
   • APIs: GraphQL, gRPC, tRPC, OpenAPI
   • Estilização: CSS, Tailwind, responsivo, modo escuro
   • Empacotamento: 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. O coprocessador diferenciável

A ALU neural injetada na passagem direta de um transformer como um expert roteado. Uma porta aprendida por token decide se cada token flui através do MLP original ou através da ALU neural. Tabelas verdade suaves bilineares fornecem lógica diferenciável, operações tensorais fornecem aritmética diferenciável, e o roteamento é modulado pela confiança do modelo.

Resultados de uma varredura de 11 modelos nas famílias Qwen 2.5/3/3.5, em tarefas aritméticas:

A transferência para o mundo real é medida, não extrapolada: no HumanEval completo (Qwen3.5-4B, A100), 62,2% → 64,6% — quatro problemas adicionais resolvidos.

5. Dinâmica preditiva de máquina JEPA

Um modelo de mundo preditivo do próprio computador. Junto com a execução exata, uma rede estilo JEPA (Joint Embedding Predictive Architecture) aprende a prever transições de estado da máquina em um espaço latente comprimido:

latent_state_t + instrução → preditor → latent_state_{t+1}

Ela opera em dois níveis. Uma demonstração Python (ncpu/jepa_neural_cpu/) executa programas reais ao lado do preditor, transformando o erro de predição em um sinal de anomalia em tempo real. Uma implementação Rust Metal (kernels/rust_metal/src/jepa/, 2.858 linhas) observa a execução determinística da GPU e direciona ativamente o escalonamento através de substituições de viés aprendidas.

Como o substrato subjacente é exato, este modelo de mundo possui duas propriedades que a maioria não tem: verdade fundamental ilimitada e gratuita (execute mais programas) e a capacidade de misturar execução predita e exata à vontade — especulação latente barata quando explorando, execução exata quando importa. A direção de longo prazo é uma hierarquia de preditores nos níveis de bit, instrução, programa e tarefa.

python3 -m ncpu.jepa_neural_cpu.demo     # demonstração do computador neural JEPA bottom-up
python -m ncpu.world_model.quickstart    # início rápido do modelo de mundo de máquina JEPA

Comece em 60 segundos

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

# A demonstração principal: a GPU como um computador completo (macOS / Apple Silicon)
python -m ncpu gpu                 # inicialize
python -m ncpu gpu --neural-alu    # com a ALU neural dentro do shader Metal
python -m ncpu gpu debug           # depurador determinístico de 26 comandos

# Multiplataforma, sem dependências pesadas
python -m ncpu discover            # programa por exemplos, via síntese diferenciável
python -m ncpu text --interactive  # máquina de texto neural / cifra

# Pipeline neural completo (requer a pilha de modelos)
python -m ncpu full-neural         # CPU neural bottom-up + tela neural
python -m ncpu meta-compare        # demonstração de comparação lado a lado

# Camada preditiva JEPA
python3 -m ncpu.jepa_neural_cpu.demo
python -m ncpu.world_model.quickstart

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

Três modos de execução

Todos os três executam os mesmos programas e produzem os mesmos resultados. O modo neural envia cada operação através de redes treinadas. O modo rápido usa tensores nativos com o mesmo ISA e a mesma diferenciabilidade. O modo computacional troca gradiente por velocidade — é onde o SO UNIX inicializa, o compilador se auto-hospeda e o BusyBox roda.

# Modo neural — cada operação é um modelo treinado
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 — calculado pela LUT de pares de bytes neural

# Coprocessador diferenciável — injete em qualquer modelo Hugging Face
from ncpu.coprocessor import inject_ncpu_coprocessor, NCPUCoprocessorConfig
config = NCPUCoprocessorConfig(confidence_aware=True, deterministic_alu=True)
inject_ncpu_coprocessor(model, config)

# Síntese diferenciável de programas
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)
# descobre: ADD R2, R0, R1; HALT

# Modelo de mundo JEPA — predizir transições de estado da máquina
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))

A pilha completa

Imunidade a canais laterais de temporização

A execução na GPU aqui produz variância zero na contagem de ciclos — σ = 0,0 em 270 execuções, onde o mesmo código no Apple Silicon nativo mostra 47–73% de variância de temporização. Sem cache de dados, não há linhas de cache e nenhuma penalidade de falta de cache, então ataques à tabela AES não têm o que medir.

Construída sobre essa propriedade, ncpu/crypto/ fornece AES-128 de tempo constante (ECB e CBC) a partir de 19 primitivas de tempo constante, passando todos os vetores de teste FIPS 197 e NIST SP 800-38A.

Motor de Máquina Auto-Otimizadora (SOME)

Um controlador oculto que transforma parte da máquina neural em um coprocessador interno para geração de código: um loop bufferizado de pensar → escrever → verificar → corrigir → confirmar, cabeças de ação/halt/descritor/patch de estado/memória aprendidas, e pesos rápidos locais à tarefa atualizados durante a inferência. A cabeça de memória aprendida melhorou o MSE de validação em 83,26% em relação à linha de base.

Medido de ponta a ponta: HumanEval+ para qwen3.5:4b melhorou 147 → 154 e para qwen3.5:9b 144 → 156; BigCodeBench-Hard para qwen3.5:9b melhorou 33 → 49.

MUXLEQ: Turing-completo em duas instruções

SUBLEQ mais MUX, rodando em todos os três modos de execução. No modo neural, SUB passa pelo carry-lookahead de Kogge-Stone (~248 µs) e MUX através de AND/OR/NOT neurais (~63 µs). Ele carrega imagens .dec e inicializa eForth. O ponto: se redes treinadas executam exatamente um computador de duas instruções (one-instruction-set), a construção se estende a qualquer conjunto de instruções.

Síntese de programas a partir de exemplos (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

Estrutura do projeto

ncpu/
  differentiable/    # Execução diferenciável, síntese de programas, descoberta de ISA
  coprocessador/       # Injeção do nCPU em passagens diretas de transformers
  execution_training/# Execução diferenciável como sinal de treinamento para LMs de código
  crypto/            # Criptografia de tempo constante (AES-128)
  distributed/       # Execução distribuída multi-GPU
  jepa_neural_cpu/   # Demonstração do computador neural JEPA bottom-up
  world_model/       # Modelo de mundo de máquina JEPA (dinâmica preditiva)
  autoresearch/      # Pesquisa automatizada + loop NPCoT compoundador
  os/
    neuros/          # SO neural: 17 módulos (MMU, TLB, cache, escalonador...)
    gpu/             # SO UNIX na GPU: shell, sistema de arquivos, carregador ELF, código C
  self_optimizing/   # SOME: controlador oculto, pesos rápidos
  neural/            # NeuralCPU: ponte da ALU neural, pipeline de tecelagem
  model/             # CPU baseada em modelos (neural_ops, montador)
  tensor/            # Emulador ARM64 baseado em tensor (diferenciável)

# Backends compilados / acelerados
kernels/             # rust_metal (kernel ARM64 Rust+Metal), mlx, npcot_wasm
nsynth/              # Motor de síntese universal: gradiente + enumerativo + busca + ML + web
                     # 420/420 cobertura de síntese, 1000+ APIs de ML, 500+ APIs web
                     # Núcleo: síntese de programas (105/105), ML/tensor (18+ módulos), web (19+ módulos)
                     # ML universal: atenção, difusão, flows, ODEs, NeRF, RL, meta-aprendizado
                     # Web completa: WASM, WebGPU, frameworks, APIs, estilização, empacotamento
packages/            # Pacotes complementares (metal_mlp)

# Modelos e corpus de síntese
models/              # Pesos dos componentes neurais treinados (veja models/MODEL_INDEX.md)
programs/            # Corpus de benchmark de síntese (aritmética, bit a bit, algoritmos, ...)

# Evidências, artigo, experimentos
artifacts/           # Resultados de benchmark consolidados citados pelo artigo + testes
paper/               # Artigo de pesquisa + seções modulares
benchmarks/          # Scripts drivers de benchmark
experiments/         # Execuções de experimentos exploratórios

# Uso e operações
examples/            # Demonstrações mínimas executáveis (uma por caminho de execução)
demos/               # Walkthroughs de demonstração maiores (BusyBox, Alpine, compilador)
scripts/             # Pontos de entrada + automação de mantenedor
tools/               # Ferramentas do desenvolvedor
training/            # Pipelines de treinamento
packaging/           # Scaffolding de implantação (Homebrew, Modal, DEPLOYMENT.md)

# Testes, docs, assets
tests/               # Suíte de testes (veja tests/README.md)
docs/                # Documentação
assets/              # Logos / assets estáticos

# Saída de construção e execução (gitignored — regenerável, não commitado)
checkpoints/         # Checkpoints grandes de pesos .pt
training_results/    # Varreduras de escalonamento do coprocessador, estudos de ablação
dist/                # Distribuições de construção
logs/  outputs/      # Logs de execução e saídas temporárias

Cada diretório de nível superior tem seu próprio README.md descrevendo seu propósito.

Testes

python -m ncpu doctor
pytest tests/ -q   # 2.500+ testes em toda a pilha

A cobertura abrange verificação formal exaustiva da ALU, operações neurais, neurOS, modo computacional, execução multiprocesso, MUXLEQ, BusyBox/Alpine, o kit de ferramentas de depuração na GPU, o coprocessador, síntese Mog, execução diferenciável, criptografia de tempo constante, programas auto-modificantes, o compilador diff, distribuição multi-GPU, SOME e os modelos preditivos JEPA.

Documentação

• Artigo de pesquisa — a análise completa e descobertas
• Artigo do kit de ferramentas de depuração na GPU — o depurador nativo da GPU de 26 comandos
• Referência do kit de ferramentas de depuração na GPU — referência de comandos
• Kernel Rust Metal — arquitetura, design de cópia zero, instruções de construção
• Pipeline de compilação — fluxo de ponta a ponta de C para GPU
• CPU neural JEPA — arquitetura de computador neural bottom-up
• Modelo de mundo de máquina JEPA — design de dinâmica preditiva
• Índice de modelos — inventário completo de modelos treinados
• Guia completo do SOME — controlador oculto e pipeline de treinamento
• Programas diferenciáveis — otimização de programas, síntese, descoberta de ISA
• Resultados de benchmark — números pass@1 para cada modo e nível de modelo

Licença

MIT