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

llama.cpp догоняет: как открытый движок для локальных LLM ускорился за несколько месяцев

Энтузиаст на ноутбуке с RTX 5080 16 ГБ обнаружил, что llama.cpp за несколько месяцев догнал его самодельный движок. Разбираем методику замера (16k prefill, 1k o

Коротко

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

  1. 01

    Что произошло: llama.cpp догнал самодельный движок за несколько месяцев

  2. 02

    Почему раньше llama.cpp проигрывал: скорость vLLM против экономии VRAM

  3. 03

    Как измеряли: 16k prefill, 1k output и оговорки автора

  4. 04

    Почему llama.cpp выигрывает у самодельного движка: зрелость против vibe-coding

Что произошло: 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 его не закрывает.

Как воспроизвести похожий замер у себя

Проверить выводы на своём железе можно без лаборатории. Порядок такой:

  1. Зафиксируйте сценарий и не меняйте его между прогонами. Рабочий вариант из источника: 16k токенов prefill и 1k токенов генерации на тексте Wikipedia.
  2. Возьмите один и тот же чекпоинт модели для всех движков. Это единственный способ получить сравнение, близкое к честному.
  3. Кванты проверяйте отдельным прогоном. Если у движков разные кванты одной модели, результаты нельзя ставить рядом: вы измеряете и движок, и квант одновременно.
  4. Подберите оптимальные настройки под каждый движок, но запишите их. Без записи повторный прогон через месяц будет бессмысленным.
  5. Прогоните сценарий несколько раз и смотрите на разброс. Один запуск после прогрева легко даёт выброс в обе стороны.

Тот же принцип применим к любому кастомному решению. В разборе теста кастомного 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, но это не превращает замер в универсальный отчёт по всем моделям семейства.

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

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