Что произошло: llama.cpp догнал самодельный движок за несколько месяцев
Несколько месяцев назад разработчик-энтузиаст завёл хобби-проект: собственный инференс-движок под ноутбучную RTX 5080 с 16 ГБ видеопамяти. Задача формулировалась прямо: проверить, получится ли обогнать llama.cpp на этом же железе. Тогда получилось без особых усилий.
При повторном прогоне бенчмарка llama.cpp догнал самодельный движок или обошёл его. Автор описал это в сабреддите r/LocalLLaMA и приложил график, который показывает рост производительности открытого движка во времени: Llama.cpp performance improvement over time.
Оговорка нужна с первой строки: это пользовательский замер, а не научное исследование. Одно железо, одна фиксированная нагрузка, настройки подбирались отдельно под каждый движок. Ценность такого замера в другом: он показывает, что реально видит человек, который запускает LLM дома и не располагает сервером на восемь ускорителей.
Второй слой истории важнее самой новости. Автор по ходу проекта менял приоритеты и в итоге сформулировал позицию, близкую большинству практиков: стабильный движок с полноценными функциями полезнее быстрого, но сырого хобби-решения. Даже если это его собственное решение.
Почему раньше llama.cpp проигрывал: скорость vLLM против экономии VRAM
Точка отсчёта: на момент старта проекта llama.cpp заметно уступал по скорости vLLM. Разрыв был достаточным, чтобы самодельная сборка на vibe-coding вышла вперёд на том же ноутбуке.
У скорости vLLM есть цена, и автор называет её прямо: этот движок расходует видеопамять очень расточительно. На сервере с несколькими GPU такой обмен выглядит разумным, потому что память там не самое узкое место. На ноутбуке с 16 ГБ обмен не работает, поскольку память заканчивается раньше, чем скорость становится главным фактором.
Поэтому преимущество самодельного движка на старте означало победу по токенам в секунду в конкретном сценарии. Про эффективность расхода VRAM это не говорило ничего.
Почему VRAM важнее пиковой скорости на ноутбуке с 16 ГБ
В 16 ГБ должны ужиться веса модели, KV-кэш под контекст и рабочие буферы движка. Кэш растёт вместе с длиной контекста: сценарий с prefill на 16k токенов сам по себе требовательный, а ведь после него ещё нужно сгенерировать 1k токенов. Чем больше памяти забирают внутренние структуры движка, тем меньше остаётся запаса на квантование и длинный контекст. Когда запас исчерпан, часть слоёв уезжает в системную RAM, и вы получаете уже другой режим работы с другой скоростью.
llama.cpp исторически строился вокруг экономного расхода памяти: квантованные веса, аккуратное размещение слоёв, совместная работа CPU и GPU. Отсюда практический вывод: самодельный движок, выигравший по токенам в секунду, не обязательно выигрывал по полезной нагрузке. Сравнение llama.cpp и vLLM измеряет не только скорость, но и то, сколько видеопамяти останется под модель. Подробный разбор этого компромисса на гибридном CPU+GPU-инференсе есть в материале llama.cpp или vLLM: что выбрать для локального запуска MoE-моделей.
Как измеряли: 16k prefill, 1k output и оговорки автора
Методика зафиксирована и не менялась от прогона к прогону: 16k токенов prefill, затем 1k токенов генерации на тексте Wikipedia, для каждого движка подбирались оптимальные настройки. Автор называет такой бенчмарк не научным, и с этим сложно спорить: один сценарий не покрывает ни чат с короткими репликами, ни агентные циклы с частыми вызовами инструментов, ни работу с кодом.
Отдельно стоит проговорить, что настройки под каждый движок подбирались индивидуально. Это честно по отношению к инструментам, но усложняет сравнение конфигураций: вы сравниваете не два одинаковых набора параметров, а два результата после ручной подгонки.
Почему 12B и 26B сравнивались по-разному
С моделями автор обошёлся по-разному, и это ключевая деталь для оценки результата.
- Для модели 12B использовался один и тот же чекпоинт во всех движках. Здесь сравнение близко к честному: одинаковые веса, одинаковая нагрузка, разница только в движке.
- Для модели 26B применялись разные кванты для всех движков. Это уже не apples-to-apples: квант влияет и на скорость, и на качество, поэтому цифры нельзя ставить рядом без сносок.
Именно второй случай делает вывод интереснее. Даже в заведомо нестройном сравнении llama.cpp выигрывает. Это усиливает общий тезис об ускорении движка, но не превращает замер в научное доказательство.
Что показывает график производительности llama.cpp
Автор собрал график из замеров, которые у него накопились за время проекта. График визуализирует динамику: как менялась производительность llama.cpp от прогона к прогону. Он иллюстрирует тренд, а не доказывает превосходство над всеми движками на всех конфигурациях.
Читать его стоит как историю изменений одного человека на одном ноутбуке. Конкретные точки по осям привязаны к его железу, его сборкам и его настройкам. Независимого аудита за этим графиком нет, и сам автор на него не претендует: пост с графиком и описанием методики опубликован в сообществе 15 ноября 2026 года.
Почему llama.cpp выигрывает у самодельного движка: зрелость против vibe-coding
Самодельный движок создавался под конкретное железо и конкретную задачу. В этом его сила на короткой дистанции: не нужно поддерживать десятки архитектур, не нужно думать о совместимости с чужими моделями и форматами квантования. На старте такой подход даёт быстрый результат.
Дальше начинается то, что автор и называет ценой хобби-решения. Нужны обновления под новые модели, багфиксы, работающие функции вроде нормального управления контекстом, поддержки разных форматов и предсказуемого поведения на длинных промптах. Один человек с помощником-моделью это тянет с трудом, а llama.cpp тянет это коллективно.
Автор формулирует вывод без обиды на собственный проект: он предпочитает стабильный движок с полноценными функциями любым решениям на vibe-coding, включая своё. Отдельно он отмечает, что проект llama.cpp, хотя и остаётся немного медленнее в отдельных сценариях, со временем выдаёт значительные улучшения производительности. Для пользователя это значит, что ставка на зрелый движок окупается не только функциями, но и скоростью: её подтягивают за вас.
Похожая логика видна и в других пользовательских сравнениях. Например, в разборе RustingStrata против llama.cpp на RTX 3060 12 ГБ альтернативный движок обогнал llama.cpp примерно на треть после прогрева, но это один замер на одной конфигурации, и делать из него общий вывод о победителе рано.
Что это значит для пользователей локальных LLM на ограниченной VRAM
Для ноутбука с RTX 5080 16 ГБ вывод звучит прозаично: llama.cpp остаётся разумным выбором по умолчанию. Он экономнее расходует видеопамять, поддерживает кванты, которые позволяют втиснуть 12B или 26B в ограниченный объём, и за несколько месяцев заметно прибавил в скорости. Вам не нужно писать свой движок, чтобы получить приемлемый темп на 16k prefill.
Критерии выбора удобно разложить по ситуации, а не по абсолютной таблице лидеров.
| Движок | Что даёт | Где ограничение |
|---|---|---|
| llama.cpp | Экономный расход VRAM, квантованные веса, зрелый набор функций, заметный прирост скорости за месяцы | В отдельных сценариях уступает по пиковой скорости |
| vLLM | Высокая скорость инференса | Расточительный расход видеопамяти, критично на 16 ГБ |
| Самодельный движок на vibe-coding | Быстрый старт под конкретное железо, на старте обгонял llama.cpp | Нет полноценных функций и коллективной поддержки, после ускорения llama.cpp потерял преимущество |
Решать стоит по четырём параметрам: сколько у вас VRAM, какая длина контекста нужна в работе (16k prefill или меньше), сколько токенов вы генерируете за раз (1k output или пара абзацев) и готовы ли вы тратить время на ручную подгонку настроек под каждый движок.
Когда всё же стоит смотреть в сторону vLLM
vLLM оправдан, когда видеопамять не узкое место, а приоритет один: максимальная скорость инференса. Сценарии с запасом VRAM, серверные конфигурации, пакетная обработка запросов, где несколько пользователей или процессов бьются в один движок. Там расточительность по памяти перестаёт быть проблемой, а скорость выходит на первый план.
На ноутбуке с 16 ГБ ситуация обратная: лишний расход памяти означает меньше контекста или более агрессивный квант. Выбор здесь определяется сценарием, и один бенчмарк с 16k prefill его не закрывает.
Как воспроизвести похожий замер у себя
Проверить выводы на своём железе можно без лаборатории. Порядок такой:
- Зафиксируйте сценарий и не меняйте его между прогонами. Рабочий вариант из источника: 16k токенов prefill и 1k токенов генерации на тексте Wikipedia.
- Возьмите один и тот же чекпоинт модели для всех движков. Это единственный способ получить сравнение, близкое к честному.
- Кванты проверяйте отдельным прогоном. Если у движков разные кванты одной модели, результаты нельзя ставить рядом: вы измеряете и движок, и квант одновременно.
- Подберите оптимальные настройки под каждый движок, но запишите их. Без записи повторный прогон через месяц будет бессмысленным.
- Прогоните сценарий несколько раз и смотрите на разброс. Один запуск после прогрева легко даёт выброс в обе стороны.
Тот же принцип применим к любому кастомному решению. В разборе теста кастомного CPU-движка на Qwen3.5 0.8B против llama.cpp видно, как сильно результат зависит от конфигурации квантования и сценария: цифры по prefill и throughput расходятся, потому что задачи разные.
Какие выводы из этого бенчмарка делать не стоит
Первое и главное ограничение: одно железо. RTX 5080 16 ГБ Laptop с конкретной системой охлаждения, конкретным драйвером и конкретными сборками движков. Переносить эти цифры на настольную карту с 24 ГБ или на сервер с несколькими GPU нельзя без собственной проверки.
Второе: фиксированная нагрузка. 16k prefill и 1k output на тексте Wikipedia описывают один тип работы. Чат с короткими репликами, генерация кода, агентные циклы с инструментами и длинные диалоги с накоплением контекста ведут себя иначе, и расстановка сил там может измениться.
Третье: разные кванты для модели 26B. Это прямое нарушение принципа apples-to-apples, о котором предупреждает сам автор. Победа llama.cpp в этом прогоне скорее говорит о запасе прочности, чем о точной величине преимущества.
Четвёртое: источник. Это пользовательский пост с графиком, а не формальное исследование, не независимый обзор и не воспроизводимый набор скриптов. Заголовок источника упоминает Gemma4 models, но это не превращает замер в универсальный отчёт по всем моделям семейства.
Полезный вывод из истории лежит не в плоскости абсолютной таблицы лидеров. Он в динамике: открытый движок за несколько месяцев прошёл путь от отставания до паритета с самодельным решением под конкретное железо. Если вы выбираете, на что ставить в локальном инференсе, ставьте на проект, который продолжает ускоряться. И проверяйте на своих моделях и своём сценарии, прежде чем переносить чужие токены в секунду в свой рабочий процесс.