207 токенов в секунду на Qwen3.5‑27B и RTX 3090: Lucebox выжимает максимум из старых GPU — VogueTech

Что нового

Lucebox показала, насколько далеко можно разогнать локальные LLM на старом, но массовом железе — RTX 3090. Проект делится на два отдельных релиза.

1. Megakernel для Qwen 3.5‑0.8B на RTX 3090

Все 24 слоя Qwen 3.5‑0.8B выполняются одним CUDA‑запуском.
На RTX 3090 (2020 года) команда получила 1,87 токена на джоуль при лимите 220 Вт.
По их данным, это сопоставимо с актуальным Apple Silicon по эффективности, но при этом примерно в 2 раза выше по пропускной способности.
Бенчмарк (prefill pp520 + decode tg128) против llama.cpp BF16 и стандартного PyTorch (HF):

| Метод | Prefill (pp520) | Decode (tg128) | tok/J | Потребление | |-------------------------|-----------------|----------------|-------|-------------| | Megakernel | 37 800 | 413 | 1.87 | 220 Вт | | llama.cpp BF16 | 11 247 | 267 | 0.76 | 350 Вт | | PyTorch HF | 7 578 | 108 | n/a | не указано |

То есть megakernel на RTX 3090 даёт примерно 3,3× больше токенов в секунду в префилле, 1,5× в декоде и примерно 2,5× токенов на джоуль по сравнению с llama.cpp BF16 на том же GPU.

2. DFlash + DDTree для Qwen 3.5‑27B GGUF на RTX 3090

Здесь Lucebox портировала алгоритм DFlash для спекулятивного декодирования на стек ggml + GGUF и добавила DDTree‑верификацию.

Модель: Qwen 3.5‑27B.
Формат таргета: Q4_K_M GGUF (~16 ГБ).
Черновик: BF16‑модель размером ~3,46 ГБ.
Алгоритм: DFlash + DDTree с budget=22.
Демо: до 207,6 токенов/с (DFlash) против 38,0 токенов/с в обычном авторегрессионном режиме (5,46× быстрее).
HumanEval 10 промптов: средняя скорость 129,5 токенов/с, что 3,43× быстрее, чем авторегрессия, и ещё +15% к скорости по сравнению с chain speculative decoding.
Math500: 110,5 токенов/с против 37,7 токенов/с (2,93×).
GSM8K: 96,2 токенов/с против 37,7 токенов/с (2,55×).
На том же RTX 3090 реализация Lucebox 2,8× быстрее, чем SGLang AWQ.
Поддерживается контекст до 128K токенов в 24 ГБ видеопамяти, при этом на длине контекста 131 072 токена скорость — 134,78 токенов/с.

Оба проекта распространяются под MIT‑лицензией, с открытым кодом, бенчмарками и подробными write‑up’ами.

Как это работает

Megakernel: один гигантский CUDA‑ядро вместо сотен мелких

Классический запуск LLM на GPU — это десятки или сотни CUDA‑ядер на каждый токен: для каждого слоя своя операция, постоянные переключения между CPU и GPU, накладные расходы на синхронизацию.

Lucebox делает наоборот:

Один persistent‑kernel вместо ~100 запусков на токен.
82 CUDA‑блока, 512 потоков каждый — всё ядро крутится непрерывно.
Нет походов на CPU между слоями: весь forward‑проход Qwen 3.5‑0.8B (24 слоя) живёт в одном ядре.
Cooperative grid sync вместо многократных запусков: синхронизация внутри одного большого ядра.
Веса стримятся напрямую с Hugging Face при первом запуске, без ручного скачивания.
При таких настройках RTX 3090 упирается сначала в лимит мощности, а не в вычислительный потолок. За счёт этого уменьшение power limit (через DVFS) переводит плотное выполнение кода прямо в экономию ватт.

Итог — меньше накладных расходов, лучше утилизация GPU и заметный выигрыш по токенам на джоуль.

DFlash + DDTree: спекулятивное декодирование с деревом проверок

Второй проект — это перенос DFlash‑декодера на стек ggml + GGUF и заточка под RTX 3090.

Ключевые идеи:

DFlash (z-lab, 2026) — блок‑диффузионный черновик (draft), который генерирует несколько токенов вперёд, опираясь на скрытые состояния таргет‑модели.
DDTree (Ringel et al., 2026) — древовидная схема проверки этих черновиков. Она даёт выигрыш по скорости относительно chain‑проверки при том же бюджете вычислений.

Lucebox не придумывает сами алгоритмы, а:

Пишет C++/CUDA‑движок декодирования поверх ggml, без libllama и без Python в рантайме.
Оптимизирует путь для Q4_K_M таргета.
Добавляет три кастомных CUDA‑ядра для отката SSM‑состояний с учётом дерева DDTree:
- ggml_ssm_conv_tree
- ggml_gated_delta_net_tree
- ggml_gated_delta_net_tree_persist
Подбирает budget=22 для DDTree как оптимум на RTX 3090 + Q4_K_M по скорости и памяти.
Использует Q4_0 KV‑кэш и скользящее кольцо признаков (sliding target_feat ring), чтобы впихнуть 128K контекста в 24 ГБ с примерно 3% попаданий по AL (accuracy loss).

Почему именно Q4_K_M GGUF

Ограничение — 24 ГБ видеопамяти RTX 3090. Команда попробовала AWQ INT4 для Qwen 3.5‑27B, но вместе с BF16‑черновиком в память уже не помещается состояние DDTree‑верификации.

В итоге они выбрали:

Q4_K_M GGUF (~16 ГБ) как таргет.
3,46 ГБ BF16‑draft.
Плюс память под дерево DDTree с budget=22 и KV‑кэш.

Это всё влезает в 24 ГБ, но потребовало нового порта DFlash поверх ggml, потому что публичных реализаций DFlash с GGUF‑таргетом не было.

Что это значит для вас

Для кого это вообще интересно

У вас есть RTX 3090 или другой Ampere‑GPU (sm_86+).
Вы хотите локально запускать Qwen 3.5‑0.8B или 3.5‑27B без облака и подписок.
Вам важны скорость генерации, длинный контекст и стоимость в ваттах, а не только «чтобы просто работало».

Если вы попадаете в это описание — Lucebox даёт готовый стек, чтобы превратить старую геймерскую видеокарту в мощный локальный LLM‑сервер.

Какие задачи закрывает Megakernel (Qwen 3.5‑0.8B)

Qwen 3.5‑0.8B — это компактная модель. В связке с megakernel она хорошо подходит для:

Чата и ассистентов прямо на ПК, когда нужен быстрый отклик.
Автодополнения кода в локальных IDE.
Автодополнения текста, e‑mail, заметок.
Лёгких ботов для внутренних сервисов и инструментов.

Плюсы:

Очень высокая скорость на RTX 3090.
Отличная эффективность по энергии — токены на джоуль выше, чем у llama.cpp BF16.
Запуск без внешних API и пер‑токеновой оплаты.

Минусы:

Модель маленькая по современным меркам. По качеству ответов она уступит тяжёлым моделям вроде Qwen 3.5‑72B, GPT‑5 или Claude 4.
Без опыта в Python/CUDA и Linux будет непросто разобраться в установке и оптимизации.

Для чего нужен DFlash‑порт Qwen 3.5‑27B

Qwen 3.5‑27B — это уже серьёзная модель для:

Генерации кода и решения задач HumanEval / GSM8K / Math500.
Сложных аналитических запросов, цепочек рассуждений.
Длинного контекста: разбор больших логов, документов, транскриптов до 128K токенов.

Плюсы:

До 207,6 токенов/с в демо и 3,43× ускорение на HumanEval по сравнению с обычным декодированием.
2,8× быстрее, чем SGLang AWQ на том же RTX 3090.
128K контекста в 24 ГБ — это серьёзный запас для реальных задач.

Минусы:

Нужен полноценный RTX 3090 с 24 ГБ VRAM. На младших картах такой конфигурации просто не хватит памяти.
Установка включает C++/CUDA билд, CMake, работу с субмодулями — это не «одна кнопка».
Это локальное решение: все вычисления идут у вас, но и вся ответственность за настройку, обновления и мониторинг тоже на вас.

Где не стоит применять

Если вам нужен максимум качества ответов без оглядки на железо, проще купить доступ к GPT‑5, Claude 4 или аналогам в облаке.
Если у вас нет дискретного NVIDIA‑GPU уровня RTX 3090, смысла в Lucebox немного — стек заточен под Ampere+ и CUDA 12+.
Если вы не готовы разбираться с компиляцией C++/CUDA, лучше использовать готовые дистрибутивы вроде LM Studio, Ollama или веб‑обёртки над облачными моделями.

Ограничений по региону у проекта нет: это GitHub + Hugging Face. Если эти ресурсы в вашей сети блокируются, может понадобиться VPN или зеркала. Всё зависит от вашего провайдера и корпоративной политики.

Место на рынке

Lucebox конкурирует не с GPT‑5 или Claude 4, а с локальными рантаймами и фреймворками.

По данным бенчмарков проекта:

Против llama.cpp BF16 на RTX 3090 (Qwen 3.5‑0.8B):
- Megakernel даёт 37 800 токенов/с префилла против 11 247.
- В декоде — 413 токенов/с против 267.
- Энергоэффективность — 1,87 токена/джоуль против 0,76.
Против стандартного PyTorch HF на том же железе:
- Prefill — 7 578 токенов/с против 37 800 у megakernel.
- Декод — 108 токенов/с против 413.
Против SGLang AWQ для Qwen 3.5‑27B на RTX 3090:
- DFlash + DDTree в реализации Lucebox 2,8× быстрее при тех же условиях.
Против обычного авторегрессионного декодера (AR):
- HumanEval: 3,43× ускорение (37,8 → 129,5 токенов/с).
- Math500: 2,93× (37,7 → 110,5 токенов/с).
- GSM8K: 2,55× (37,7 → 96,2 токенов/с).
- В демо: 5,46× (38,0 → 207,6 токенов/с).

На фоне «однажды‑собранных» универсальных стеков Lucebox идёт по пути жёсткой заточки под конкретное железо и конкретные модели. Цена — повышенная сложность установки и меньшая универсальность. Выигрыш — ощутимый прирост скорости и эффективности именно на RTX 3090.

Установка

Требования

Общие для репозитория:

NVIDIA GPU уровня Ampere+ (sm_86+) — ориентир RTX 3090.
CUDA 12+.
PyTorch 2.0+.
Для DFlash‑части нужен CMake 3.18+.
Клонирование репозитория с сабмодулями обязательно для DFlash, так как он использует форк Luce-Org/llama.cpp@luce-dflash с тремя tree‑режимами ggml.

Дополнительно, чтобы найти оптимальный баланс скорости и энергопотребления для megakernel, Lucebox рекомендует ограничить power limit на RTX 3090:

sudo nvidia-smi -pl 220

По их замерам 220 Вт даёт лучшее соотношение токенов к джоулю.

Как запустить Megakernel (Qwen 3.5‑0.8B)

Клонируем репозиторий и заходим в папку megakernel:

git clone https://github.com/Luce-Org/lucebox-hub && cd lucebox-hub/megakernel

Устанавливаем зависимости (Python 3.10+, CUDA 12+, PyTorch 2.0+). Веса подтянутся с Hugging Face при первом запуске:

pip install -e .

Запускаем финальный бенчмарк (prefill pp520 + decode tg128) и сравниваем с llama.cpp BF16 и PyTorch HF:

python final_bench.py

Ожидаемая таблица по данным авторов:

| Метод | Prefill pp520 | Decode tg128 | tok/J | |---------------------|---------------|--------------|-------| | Megakernel @220W | 37,800 | 413 | 1.87 | | llama.cpp BF16 @350W| 11,247 | 267 | 0.76 | | PyTorch HF | 7,578 | 108 | n/a |

Как запустить DFlash + DDTree (Qwen 3.5‑27B)

Клонируем репозиторий с сабмодулями, чтобы подтянуть форк Luce-Org/llama.cpp@luce-dflash:

git clone --recurse-submodules https://github.com/Luce-Org/lucebox-hub && cd lucebox-hub/dflash

Собираем C++/CUDA‑декодер (примерно 3 минуты на sm_86, CUDA 12+, CMake 3.18+):

cmake -B build -S . -DCMAKE_CUDA_ARCHITECTURES=86 -DCMAKE_BUILD_TYPE=Release
cmake --build build --target test_dflash -j

Скачиваем веса таргета и черновика:

# ~16 ГБ Q4_K_M таргет
huggingface-cli download unsloth/Qwen3.5-27B-GGUF Qwen3.5-27B-Q4_K_M.gguf --local-dir models/

# 3.46 ГБ BF16-драфт
huggingface-cli download z-lab/Qwen3.5-27B-DFlash model.safetensors --local-dir models/draft/

4a. Запускаем однократную генерацию в потоковом режиме:

python3 scripts/run.py --prompt " def fibonacci(n): "

4b. Или воспроизводим «paper‑style» бенчмарк (HumanEval + GSM8K + Math500, около 15 минут):

python3 scripts/bench_llm.py

Ожидаемые результаты по данным Lucebox:

Benchmark          AR (tok/s)   DFlash+DDTree (tok/s)   Speedup
HumanEval          37.8         129.5                   3.43×
Math500            37.7         110.5                   2.93×
GSM8K              37.7         96.2                    2.55×

Структура репозитория и планы

Репозиторий lucebox-hub сейчас состоит из трёх основных частей:

lucebox-hub/
├── megakernel/  · fused forward pass для Qwen 3.5-0.8B
├── dflash/      · порт DFlash speculative decoding для Qwen 3.5-27B на RTX 3090
└── assets/      · баннеры, карточки, диаграммы

Дорожная карта проекта:

Q1 2026 — ядра и оптимизации для RTX 3090 (уже сделано).
Q2 2026 — оптимизации для Ryzen AI MAX+ 395.
Q2 2026 — оптимизации по задержке для гетерогенных CPU + GPU‑конфигураций.

Контекст и философия Lucebox

Lucebox исходит из простой идеи:

Локальный AI должен быть нормой, а не привилегией.
Данные остаются у вас, нет пер‑токеновой оплаты и привязки к одному вендору.
У многих уже стоит достаточно мощное железо, чтобы запускать сильные модели.

Проблема в том, что общее ПО для LLM часто не использует железо по максимуму. Универсальные фреймворки удобны, но оставляют на столе заметную часть производительности.

Команда опирается на то, что AI‑ассистенты ускорили разработку низкоуровневого кода. То, что раньше требовало квартала, теперь можно переписать за один релиз. Lucebox публикует такие «переписанные под один чип и одну модель» стеки как:

MIT‑лицензированный исходный код.
Подробные write‑up’ы в стиле научных статей.
Воспроизводимые бенчмарки.

Проект вдохновлён:

Hazy Research — идеей megakernel и методологией «интеллект на ватт».
z-lab/DFlash (Wang et al., 2026) — самим блок‑диффузионным алгоритмом спекулятивного декодирования и опубликованными весами Qwen3.5‑27B‑DFlash.
DDTree (Ringel & Romano, 2026) — древовидной схемой верификации, которая даёт DFlash 27B примерно 3,5× ускорение над chain‑подходом.
AlpinDale/qwen_megakernel и Infatoshi/MegaQwen — ранними реализациями fused‑ядер для Qwen.

Если вам интересно, куда может доехать ваш RTX 3090 без апгрейда железа, Lucebox — это пример того, что даёт ручная оптимизация LLM‑инференса под конкретный GPU.