nCPU

Полноценный компьютер, в котором каждый слой — арифметика, ОС, компилятор, дисплей — представляет собой либо обученную нейронную сеть, либо полностью работает на GPU.
Модель не работает на компьютере. Модель является компьютером.

nCPU — это один репозиторий, реализующий одну тезисную идею с пяти направлений: компьютер может быть построен из обученных компонентов, и как только весь стек выполнения становится дифференцируемым, программы перестают быть тем, что вы пишете, и становятся тем, что можно искать с помощью градиентного спуска. Каждая подсистема ниже опирается на собственные измерения; вместе они охватывают весь стек от отдельных операций АЛУ до операционной системы и синтеза программ.

Пять подсистем

1. Нейронный компьютер

Каждая операция АЛУ — сложение, вычитание, умножение, битовые операции, сдвиги, деление — реализована обученной нейронной сетью. Нейронная ОС (neurOS) управляет памятью, планирует процессы и компилирует код с помощью 11 обученных моделей без резервных реализаций, написанных вручную. Нейронный дисплей отображает символы через MLP-преобразования «символ → глиф» и свёрточную сеть (143K параметров). Полный конвейер — исходный код → нейронный компилятор → нейронный ассемблер → нейронный ЦПУ → нейронный дисплей — дифференцируем от начала до конца.

Нейронное АЛУ достигает 100% точности на 32-битных целочисленных арифметических операциях, что подтверждено исчерпывающей проверкой для всех возможных входных данных. Один из результатов переворачивает традиционную иерархию аппаратного обеспечения: умножение здесь в 12 раз быстрее сложения, потому что сложение требует 8-проходной цепочки переноса, а умножение разбивается на параллельные табличные поиски по парам байтов.

Точность компонентов neurOS:

2. GPU-компьютер

Самодостаточный компьютер на одном GPU — ЦПУ задействован только на этапе загрузки. Ядро на Rust + Metal выполняет около 200 инструкций ARM64 (целочисленные и с плавающей точкой) со скоростью примерно 1.9 млн инструкций в секунду, с нулевым копированием в разделяемой памяти и нулевой вариацией количества циклов между запусками (σ = 0.0).

Что на нём работает:

• Многопроцессная UNIX-ОС: fork/pipe/wait, командная оболочка (25 команд), 28 системных вызовов, до 15 параллельных процессов
• Самохостинговый компилятор C (~4 200 строк), который компилирует сам себя, а затем компилирует и запускает другие программы — полностью на GPU
• Настоящие бинарники Linux через загрузчик ELF64: BusyBox (264 КБ, 34+ команды) и Alpine Linux v3.20
• 13+ скомпилированных C-приложений: SHA-256, AES-128, Тетрис, Змейка, интерпретатор Brainfuck, REPL Forth, эмулятор CHIP-8, HTTP-сервер, классификатор MNIST и другие
• 26-командный детерминированный отладчик: трассировка инструкций, точки останова и точки наблюдения, отладка с перемещением во времени, санитайзер памяти, автоматический фаззинг, обратный анализ потока данных и верификация постоянства времени. Детерминированное выполнение делает возможными перемещение во времени и точное воспроизведение; обычные ЦПУ из-за шума времени выполнения, связанного с кэшем и спекуляциями, не могут предоставить таких же гарантий.

3. nSynth: Универсальный движок синтеза

nSynth — это система синтеза программ на Rust, которая находит исполняемые программы по примерам входных/выходных данных с использованием градиентного спуска, перебора и поиска. В сочетании с комплексным движком машинного обучения/тензоров и полным веб-стеком, она позволяет синтезировать:

• Алгоритмы: арифметические, битовые, структуры данных, алгоритмы
• Модели машинного обучения: CNN, RNN, Transformer, GNN, Diffusion, Flows, RL-агенты
• Веб-приложения: полный стек React/Next.js, API, стилизация, WebGL, WASM-приложения

Покрытие: 420/420 задач синтеза (Mog: 315/315, nSynth: 105/105)

Три столпа:

1. Синтез программ (ядро): 105/105 задач решены с помощью градиентного поиска, переборного синтеза, сопоставления шаблонов и семейств поиска
2. Движок ML/Тензоров (1000+ API): Полные тензорные операции с автоматическим дифференцированием, позволяющие синтезировать ЛЮБУЮ архитектуру машинного обучения:
   • Механизмы внимания (MultiHeadAttention, RoPE, ALiBi, FlashAttention, Linformer, Performer)
   • Генеративные модели (Diffusion DDPM/DDIM, нормализующие потоки RealNVP/MAF, нейронные ODE)
   • Компьютерное зрение (3D Conv, деформируемая свёртка, признаки Фурье, объёмный рендеринг NeRF)
   • Обучение с подкреплением (Policy Gradients, PPO, A3C, Experience Replay, GAE, функции ценности)
   • Мета-обучение (MAML, Reptile, DARTS, ENAS NAS)
   • Вероятностное ML (байесовская нейронная сеть, MC Dropout, вариационный вывод, KL-дивергенция)
   • Эффективность (прореживание, квантование, дистилляция знаний, распределённое обучение)
3. Веб-стек (500+ API): Полноценный веб-синтез с полным покрытием:
   • Ядро: HTTP, WebSocket, SSL, JSON, Cookies, Формы, Промежуточное ПО
   • Фреймворки: React, Vue, Svelte, Solid, Next.js, Remix
   • Современное: WASM, WebGPU, WebAuthn, WebRTC, PWA
   • API: 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. Дифференцируемый сопроцессор

Нейронное АЛУ, внедрённое в прямой проход трансформера в качестве маршрутизированного эксперта. Обученный пере-токенный вентиль решает, проходит ли каждый токен через исходный MLP или через нейронное АЛУ. Билинейные мягкие таблицы истинности обеспечивают дифференцируемую логику, тензорные операции — дифференцируемую арифметику, а вентилирование модулируется уверенностью модели.

Результаты прогона 11 моделей из семейств Qwen 2.5/3/3.5 по арифметическим задачам:

Перенос на реальные задачи измерен, а не экстраполирован: на полном 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    # с нейронным АЛУ внутри шейдера Metal
python -m ncpu gpu debug           # 26-командный детерминированный отладчик

# Кроссплатформенная, без тяжёлых зависимостей
python -m ncpu discover            # программа по примерам через дифференцируемый синтез
python -m ncpu text --interactive  # нейронный текст / шифровальная машина

# Полный нейронный конвейер (требуется стёк моделей)
python -m ncpu full-neural         # нейронный ЦПУ «снизу вверх» + нейронный дисплей
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

Три режима выполнения

Все три выполняют одни и те же программы и дают одинаковые результаты. Нейронный режим пропускает каждую операцию через обученные сети. Быстрый использует нативные тензоры с той же системой команд и той же дифференцируемостью. Вычислительный режим жертвует потоком градиента ради скорости — именно в нём загружается UNIX-ОС, компилятор проходит самохостинг и работает 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 — вычислено нейронной таблицей поиска по парам байтов

# Дифференцируемый сопроцессор — внедрение в любую модель 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 даёт нулевую вариацию количества циклов — σ = 0.0 для 270 запусков, тогда как тот же код на нативном Apple Silicon показывает 47–73% вариацию. Поскольку нет кэша данных, нет строк кэша и штрафа за промах кэша, поэтому атаки на T-таблицы AES не имеют что измерять.

Основываясь на этом свойстве, ncpu/crypto/ предоставляет AES-128 с постоянным временем (ECB и CBC) из 19 примитивов с постоянным временем, проходя все тестовые векторы FIPS 197 и NIST SP 800-38A.

Движок самооптимизирующейся машины (SOME)

Скрытый контроллер, который превращает часть нейронной машины во внутренний сопроцессор для генерации кода: буферизованный цикл «думать → записать → проверить → исправить → зафиксировать», обученные головы действия/остановки/дескриптора/исправления состояния/памяти и локальные быстрые веса, обновляемые во время вывода. Обученная голова памяти улучшила MSE валидации на 83.26% по сравнению с базовым уровнем.

Измеренные сквозные результаты: HumanEval+ для qwen3.5:4b улучшен со 147 до 154, а для qwen3.5:9b со 144 до 156; BigCodeBench-Hard для qwen3.5:9b улучшен с 33 до 49.

MUXLEQ: Тьюринг-полнота на двух инструкциях

SUBLEQ плюс MUX, работающие во всех трёх режимах выполнения. В нейронном режиме SUB проходит через цепочку переноса Kogge-Stone (~248 мкс), а MUX — через нейронные AND/OR/NOT (~63 мкс). Загружает образы .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/# Дифференцируемое выполнение как обучающий сигнал для языковых моделей кода
  crypto/            # Криптография с постоянным временем (AES-128)
  distributed/       # Распределённое выполнение на нескольких GPU
  jepa_neural_cpu/   # Демонстрация JEPA нейронного компьютера «снизу вверх»
  world_model/       # JEPA модель мира (предиктивная динамика)
  autoresearch/      # Автоматизированное исследование + циклический NPCoT
  os/
    neuros/          # Нейронная ОС: 17 модулей (MMU, TLB, кэш, планировщик...)
    gpu/             # GPU UNIX-ОС: оболочка, файловая система, загрузчик ELF, исходный код C
  self_optimizing/   # SOME: скрытый контроллер, быстрые веса
  neural/            # NeuralCPU: мост нейронного АЛУ, конвейер сплетения
  model/             # Модельный ЦПУ (neural_ops, ассемблер)
  tensor/            # Тензорный эмулятор ARM64 (дифференцируемый)

# Скомпилированные / ускоренные бэкенды
kernels/             # rust_metal (ядро ARM64 Rust+Metal), mlx, npcot_wasm
nsynth/              # Универсальный движок синтеза: градиент + перебор + поиск + ML + web
                     # Покрытие синтеза 420/420, 1000+ ML API, 500+ web API
                     # Ядро: синтез программ (105/105), ML/тензоры (18+ модулей), web (19+ модулей)
                     # Универсальное ML: внимание, диффузия, потоки, ODE, NeRF, RL, мета-обучение
                     # Полный веб: WASM, WebGPU, фреймворки, API, стилизация, сборка
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/              # Логотипы / статические ресурсы

# Вывод сборки и выполнения (игнорируется git — пересоздаётся, не коммитится)
checkpoints/         # Большие файлы весов .pt
training_results/    # Масштабные прогоны сопроцессора, абляционные исследования
dist/                # Дистрибутивы сборки
logs/  outputs/      # Журналы выполнения и черновые выходные данные

Каждая директория верхнего уровня имеет собственный README.md, описывающий её назначение.

Тесты

python -m ncpu doctor
pytest tests/ -q   # 2 500+ тестов по всему стеку

Покрытие включает исчерпывающую формальную верификацию АЛУ, нейронных операций, neurOS, вычислительного режима, многопроцессного выполнения, MUXLEQ, BusyBox/Alpine, набора инструментов отладки GPU, сопроцессора, синтеза Mog, дифференцируемого выполнения, криптографии с постоянным временем, самомодифицирующихся программ, diff-компилятора, распределения на нескольких GPU, SOME и предиктивных моделей JEPA.

Документация

• Исследовательская статья — полный анализ и находки
• Статья о наборе инструментов отладки GPU — 26-командный отладчик, нативный для GPU
• Справочник набора инструментов отладки GPU — справочник команд
• Ядро Rust Metal — архитектура, дизайн с нулевым копированием, инструкции по сборке
• Конвейер компиляции — сквозной поток C→GPU
• JEPA нейронный ЦПУ — архитектура нейронного компьютера «снизу вверх»
• JEPA модель мира — дизайн предиктивной динамики
• Индекс моделей — полный перечень обученных моделей
• Полное руководство по SOME — скрытый контроллер и конвейер обучения
• Дифференцируемые программы — оптимизация программ, синтез, обнаружение ISA
• Результаты бенчмарков — показатели pass@1 для каждого режима и уровня модели

Лицензия

MIT