Перейти к содержанию
Публикация AiManual

TinyCoder: как на грант Яндекса написали C++/CUDA-движок для локального AI-кодинга

TinyCoder - локальный движок инференса и агент для кодинга на C++20 и CUDA, написанный на грант Яндекса в 600 000 рублей. Разбираем архитектуру, гибридный режим

Коротко

Что будет в материале

  1. 01

    Что такое TinyCoder и из чего он состоит

  2. 02

    Грант Яндекса на SourceCraft: как np превратился в TinyCoder

  3. 03

    Архитектура tinycoder-inference: C++20, CUDA и минимум зависимостей

  4. 04

    Гибридный режим для MoE: большая модель на 11 ГБ VRAM

TinyCoder - локальный движок инференса и агент для программирования, который автор проекта np написал на грант Яндекса в 600 000 рублей. Деньги он получил по грантовой программе для open-source проектов на платформе SourceCraft и направил их на C++/CUDA-движок для запуска LLM на собственной видеокарте. Автор описал итоги в статье на Habr.

Цифра, из-за которой проект заметили: на старой RTX 2080 Ti движок выдаёт 53.6 tok/s на генерации для MoE-модели Ornith-1.5-35B-A3B, тогда как llama.cpp в тех же условиях показывает 17.1 tok/s. Это замеры одного человека на одной карте, и ниже разобрано, что с ними можно делать, а чего они не доказывают.

Практический смысл проще амбиций: получить локального ассистента для кода, который работает без облака, не берёт денег за токены и запускает модели крупнее, чем позволяет объём VRAM. Плата за это - молодой проект, узкий список поддерживаемых моделей и сборка из исходников своими руками.

Что такое TinyCoder и из чего он состоит

TinyCoder собран из трёх частей, у каждой свой язык и своя зона ответственности.

  • tinycoder-inference - ядро на C++20 и CUDA. Считает сам инференс: читает веса, держит KV-кэш, выполняет матричные умножения и внимание на GPU.
  • tinycoder-openai - шлюз на Go. Поднимает HTTP-сервер с OpenAI- и Anthropic-совместимыми API, поддерживает tool_calls и SSE-стриминг.
  • Плагин для VS Code - клиентская часть, с которой начинается работа в редакторе.

Ядро, шлюз и плагин: три части одного пайплайна

Поток данных выглядит так: VS Code отправляет запрос в tinycoder-openai, шлюз превращает его в вызов ядра, tinycoder-inference считает токены на GPU и возвращает результат. Стриминг идёт через SSE, поэтому текст появляется в редакторе по мере генерации, а не одним куском в конце.

Разделение на слои даёт гибкость. Ядро можно вызывать напрямую, без шлюза, если нужна только генерация. Шлюз пригодится, когда у вас уже настроены клиенты под OpenAI API: достаточно указать им локальный endpoint, и переписывать интеграции не придётся. Совместимость с Anthropic API закрывает вторую половину инструментов, которые умеют работать только с этим протоколом.

Зачем вообще локальный агент для кодинга. Три причины, и все практические: код не покидает машину, нет счёта за токены при интенсивной работе, генерация доступна без сети. Ограничения тоже на месте: скорость и качество упираются в вашу видеокарту и в открытые веса, а не в серверную инфраструктуру провайдера.

Грант Яндекса на SourceCraft: как np превратился в TinyCoder

В начале 2026 года Яндекс запустил программу грантов для open-source проектов на своей платформе SourceCraft. Автор подал туда np: C++-аналог NumPy с поддержкой CUDA и ручными оптимизациями SIMD под AVX2, AVX-512 и AMX. По его замерам, np обходит оригинал по скорости в 2-20 раз и тратит примерно в полтора раза меньше памяти. Проект вошёл в список победителей, и на счёте оказалось 600 000 рублей.

По условиям конкурса грант выдаётся проектам с чётким планом развития, так что деньги шли под конкретный план, а не на свободные эксперименты. Размышляя, куда направить силы, автор выбрал локальный AI-кодинг как самое перспективное направление и положил в основу np и ещё пару собственных библиотек линейной алгебры. Подать их отдельной заявкой было нельзя: правило конкурса - один проект, один грант.

Роли стоит разделить, чтобы не путаться. Яндекс дал грант и платформу, код TinyCoder написал автор np, продуктом Яндекса проект не стал. Это независимая open-source-инициатива, выросшая из грантовой заявки на другую библиотеку.

Архитектура tinycoder-inference: C++20, CUDA и минимум зависимостей

«С нуля» здесь значит буквально: в проекте нет llama.cpp, нет ggml, нет ONNX Runtime или PyTorch. Внешних зависимостей две - собственная библиотека np и cuBLAS. Всё остальное написано автором: загрузка весов, планирование памяти, кэш контекста, ядра под конкретные операции.

Такой подход даёт контроль над каждым уровнем. Раскладку тензоров можно подогнать под конкретную карту, выкинуть универсальные ветвления, которые нужны движку на десять архитектур, и потратить освободившиеся такты на то, что важно при генерации токенов.

Цена тоже понятна. llama.cpp держит десятки архитектур и форматов, у него огромное сообщество, готовые сборки и годы обкатки на разном железе. TinyCoder уже: Qwen, Ornith, Gemma и тернарные модели, форматы GGUF и EXL3. Всё, что вне этого списка, работать не обязано. Совместимость с вашей моделью придётся проверять самому, а бенчмарки пока есть только от автора проекта.

Что берёт на себя np, а что - cuBLAS

np - C++-аналог NumPy с поддержкой CUDA и ручными оптимизациями SIMD под AVX2, AVX-512 и AMX. Именно np автор подавал на грант, поэтому движок логично вырос вокруг неё: тензорные операции, поэлементные вычисления, часть CUDA-ядер и векторные пути на CPU закрывает она. cuBLAS берёт на себя стандартные матричные умножения на GPU, те самые GEMM, где NVIDIA годами доводит ассемблер.

Граница ответственности простая. np отвечает за специфику проекта: раскладку, конвертацию форматов, часть ядер. cuBLAS считает тяжёлые матмулы. Писать собственный GEMM вместо cuBLAS имеет смысл разве что при очень необычной задаче, и в списке зависимостей этого нет.

Поддержка GGUF, EXL3, Qwen, Gemma и тернарных моделей

Движок читает два формата весов. GGUF - привычный контейнер из мира llama.cpp, под него выложено больше всего готовых квантов. EXL3 - отдельный формат квантизации с другой логикой упаковки и своими весами. Поддержка обоих расширяет выбор: можно взять то, что уже лежит на диске, и не переконвертировать всё в один формат.

Из моделей заявлены семейства Qwen, Ornith и Gemma плюс тернарные модели, где веса сжаты до трёх значений. Тернарные веса - отдельная ниша: они экономят память, но требуют своих ядер и не всегда дружат с качеством на сложном коде. Что выигрывает по bpw и когда лучше брать GGUF, а когда EXL3, разбираем в материале про локальные модели и движки под кодинг на 2×RTX 5080.

Гибридный режим для MoE: большая модель на 11 ГБ VRAM

MoE-модель устроена так: параметров много, но на каждый токен активируется лишь часть экспертов. У Ornith-1.5-35B-A3B 35 млрд параметров в названии и порядка 3 млрд активных на токен, это и означает суффикс A3B. Считать приходится меньше, чем предполагает размер весов, но хранить всё равно нужно всё.

Отсюда гибридный режим. Если веса не влезают в 11 ГБ VRAM, движок держит в видеопамяти то, что используется постоянно, и подгружает остальное из оперативной памяти по мере надобности. Планирование контекста по доступной памяти - ключевая часть схемы: длина контекста, KV-кэш и набор экспертов делят один и тот же бюджет VRAM, и движку приходится выбирать, что оставить на карте.

Почему Ornith-1.5-35B-A3B - показательный пример

Эта модель удобна как демонстрация: 35 млрд параметров целиком в 11 ГБ не поместятся ни в каком разумном кванте, а с активными 3 млрд на токен она остаётся осмысленной для кодинга. Цифры из бенчмарка относятся именно к такому сценарию: часть работы на GPU, часть через оперативную память.

Из этого не следует, что любая MoE-модель похожего размера покажет те же tok/s. Скорость зависит от числа экспертов, от того, насколько удачно они ложатся в память, от длины контекста и пропускной способности шины между CPU и GPU. Гибридный режим - компромисс: он позволяет запустить модель, которая иначе не стартовала бы, и стоит части скорости на каждом токене.

Бенчмарки на RTX 2080 Ti: 53.6 против 17.1 tok/s и что за этим стоит

Заявленные цифры: RTX 2080 Ti, MoE-модель Ornith-1.5-35B-A3B, генерация 53.6 tok/s у TinyCoder против 17.1 tok/s у llama.cpp. На префилле движок тоже быстрее. Разрыв на генерации больше чем в три раза, и это самая интересная часть: генерация обычно упирается в память и накладные расходы, а не в чистую арифметику.

Оговорки, без которых цифры читаются неправильно. Это замеры автора проекта, а не независимый тест. Условия - версия и сборка llama.cpp, параметры контекста, тип квантизации, драйверы - раскрыты неполно, а от них зависит половина результата. RTX 2080 Ti относится к архитектуре Turing, без тензорных ядер новых поколений и без части современных форматов, поэтому переносить пропорции на RTX 4090 или RTX 5090 нельзя: там узкие места другие.

Почему префилл и генерация ведут себя по-разному. Префилл обрабатывает весь промпт сразу, это почти чистые матричные умножения, и здесь всё решает GEMM. Генерация выдаёт токены последовательно, и тут важнее память: сколько весов прочитано на токен, сколько раз пришлось сходить в RAM, насколько эффективен кэш. Движок, который аккуратно раскладывает веса между VRAM и RAM, на генерации выигрывает больше, чем на префилле.

Что выбрать: TinyCoder или llama.cpp

llama.cpp остаётся базовым выбором для локального инференса, и причины веские: широчайшая поддержка моделей и форматов, большое сообщество, готовые сборки, отработанные сценарии на CPU и GPU. TinyCoder - узкий инструмент под конкретную задачу, локальный кодинг на MoE-моделях при ограниченной VRAM, и преимущество проявляется именно там.

Выбор зависит от нагрузки. Нужна максимальная совместимость и запуск с первого раза - llama.cpp. Нужен локальный агент для кода на карте с 11 ГБ и хочется выжать tok/s на MoE - есть повод сравнить TinyCoder на своей модели. Промежуточный вариант - специализированная сборка llama.cpp под одну модель; мы разбирали, где такой форк даёт прирост, а где упирается в память и квантование.

Воспроизвести замер можно самому, и это лучший способ проверить цифры. Что должно совпасть:

  • та же модель и тот же файл весов, одинаковый квант в GGUF или EXL3;
  • одинаковый промпт и одинаковая длина контекста;
  • замер после прогрева, а не на первом запросе: первый прогон включает загрузку весов и компиляцию ядер;
  • tok/s считается на генерации отдельно от префилла, иначе цифры несравнимы;
  • один и тот же режим: гибридный или полностью в VRAM.

Если результат расходится с заявленным в разы, дело обычно в кванте, длине контекста или в том, что часть модели уехала в RAM.

Как встроить TinyCoder в рабочий процесс: API, tool_calls и VS Code

tinycoder-openai поднимает HTTP-сервер с API, совместимым с OpenAI и Anthropic. Смысл в том, что переписывать клиентов не нужно: подойдёт любой инструмент, который умеет задавать свой base URL и работать с OpenAI-совместимым endpoint. Стриминг идёт через SSE, tool_calls поддерживаются.

В VS Code работа идёт через плагин, ядро при этом можно вызывать и напрямую. При запуске согласовать придётся несколько вещей: путь к весам в GGUF или EXL3, объём доступной VRAM, длину контекста и решение, включать ли гибридный режим для MoE. Готовой пошаговой инструкции по установке в исходных материалах нет, так что сборка C++20/CUDA-проекта останется на вас.

Где пригодятся tool_calls в локальном агенте

tool_calls - механизм, через который модель просит выполнить действие: прочитать файл, запустить команду, обратиться к инструменту. В локальном сценарии весь цикл остаётся на машине: запрос, вызов инструмента, результат и следующий шаг не уходят во внешнее облако. Для кода, который нельзя отправлять наружу, это основной аргумент в пользу такого стека.

Границы возможностей плагина VS Code в исходных материалах не расписаны, поэтому рассчитывать стоит на базовый сценарий: чат с моделью в редакторе и вызовы инструментов через API. Насколько агентная оболочка меняет работу, видно по соседним проектам: открытый терминальный агент MiniMax Code собран вокруг той же идеи, но с другим набором ограничений.

Кому подходит TinyCoder, а кому пока нет

Подходит, если у вас GPU с 11-24 ГБ VRAM, вы хотите локального агента для программирования и готовы собирать C++20/CUDA-проект. Отдельная категория - те, кто уже упёрся в потолок llama.cpp на MoE-моделях и хочет проверить альтернативу на своих весах.

Пока не подходит, если нужна поддержка широкого зоопарка моделей и форматов из коробки, если важна предсказуемость зрелого проекта с большим сообществом, если нет GPU и вы рассчитываете на CPU-инференс. Ещё один стоп-сигнал: бенчмарки есть только от автора, независимых прогонов нет.

Какой сценарий локального кодинга реально работает на одной машине, видно по смежным отчётам: разбор запуска Qwen3.8-Flash-Next на DGX Spark с 10 000 строк кода. TinyCoder решает ту же задачу другими средствами: не самая большая модель на дорогом железе, а аккуратная работа с памятью на карте, которая уже стоит в системном блоке.

Что проверить перед тем, как пробовать

  • Объём VRAM и поддержку нужной квантизации.
  • Наличие весов вашей модели в GGUF или EXL3: конвертировать из другого формата придётся самому.
  • Готовность собирать C++20/CUDA-проект и разбираться с ошибками сборки.
  • Совместимость клиента с OpenAI или Anthropic API.

Если хотя бы один пункт не выполняется, сначала оцените llama.cpp: возможно, его возможностей хватит. Критерий проверки простой: запустить свою модель, замерить tok/s на своём промпте и сравнить с текущим движком.

Планы развития: спекулятивное декодирование, RTX 4090/5090, мульти-GPU и NPU Intel

Дальше в планах пять направлений. Это именно планы: сроки не заявлены, готовых функций за ними пока нет.

  • Спекулятивное декодирование. Черновая модель предлагает несколько токенов, основная проверяет их пачкой. Потенциальный рост tok/s на генерации без потери качества, если черновая модель часто угадывает. Это прямой способ ускорить тот этап, где TinyCoder уже выигрывает.
  • Тюнинг под RTX 4090 и RTX 5090. У этих карт другая память и пропускная способность, ядра, настроенные под Turing, их потенциал не раскрывают. Отдельная работа нужна, чтобы цифры на актуальном железе соответствовали железу.
  • Мульти-GPU и NVLink. Несколько карт с быстрой связью между ними позволяют держать более крупные модели и распределять слои без потери на шине PCIe.
  • Распределённый инференс. Возможность считать модель не на одной машине, а на нескольких, что расширяет потолок по памяти и позволяет собирать домашний стенд из имеющегося железа.
  • Поддержка NPU Intel. Выход за пределы CUDA: ноутбуки и мини-ПК с NPU получили бы локальный инференс без дискретной видеокарты.

Оценивать эти пункты стоит по мере появления кода, а не анонсов. Пока известны только сами направления.

Что делать сейчас: если у вас лежит MoE-модель в GGUF и карта на 11-16 ГБ, прогоните её на TinyCoder тем же промптом, которым пользуетесь в llama.cpp, и сравните tok/s после прогрева. Разница не подтвердится - вы потеряли вечер на сборку. Подтвердится - у вас локальный агент, который не отправляет код в облако и не считает токены.

Подписаться на канал