30B-Modelle mit 300 tok/s auf einer einzelnen RTX 5090 betreiben
Warum keine bestehende Inference-Engine Consumer-Blackwell voll ausnutzt, was NVFP4 ändert, und die Zahlen aus dem Bau einer Engine, die es tut.
Eine einzelne RTX 5090 dekodiert 30B-total-MoE-Modelle (~3B aktive Parameter) mit rund
300 Tokens pro Sekunde, Single-Stream, Batch 1.
Nicht im Labor, nicht hochgerechnet, sondern gemessen, auf meinem Schreibtisch,
reproduzierbar bis auf den Commit-SHA. Das Überraschende ist nicht die Zahl. Es ist, dass
keine bestehende Engine auf sm_120 einen nativen NVFP4-Decode-Pfad hat, und deshalb
keine an imps Single-Stream-FP4-Decode auf dieser Karte herankommt.
Diese Lücke ist der ganze Grund, warum es imp gibt. Dieser Post handelt davon, was drinsteckt und warum eine Grafikkarte für 2.000 Dollar den Großteil ihres eigenen Siliziums abgeschaltet ließ.
Eine 5090 ist keine kleine Rechenzentrums-GPU#
Auf dem Papier sieht die 5090 aus wie eine geschrumpfte B200: dieselbe
Blackwell-Architektur, FP4-Tensor-Cores, 32 GB schneller Speicher. In der Praxis ist der
Consumer-Chip (sm_120a) eine andere Maschine, die denselben Familiennamen trägt. Ihm
fehlt der Async-Compute-Pfad, um den die Rechenzentrums-Blackwell-Kernels herum gebaut
sind (tcgen05/TMEM); die Async-Copy-Engine (TMA, cp.async) behält er.
Rechenzentrums-Blackwell - B200 (sm_100)
- tcgen05 / TMEM Async MMA
- TMA / cp.async Copy-Engine
- FP4-Tensor-Cores
Consumer-Blackwell - RTX 5090 (sm_120a)
- tcgen05 / TMEM
- TMA / cp.async Copy-Engine
- FP4-Tensor-Cores
- 32 GB GDDR7 @ 1,79 TB/s
Diese Diskrepanz spaltet das Ökosystem sauber, und nicht zugunsten der 5090:
- vLLM ist für Rechenzentrums-Blackwell gebaut, und dort ist es exzellent. Sein
NVFP4-Pfad setzt
tcgen05voraus, einen Befehl, den die 5090 nicht hat, also fällt es auf einer Consumer-Karte auf langsamere Kernels zurück oder lädt diesen Pfad gar nicht erst. Anderes Ziel, kein Mangel. - llama.cpp läuft absichtlich auf allem, das ist eine echte Stärke und der Grund, warum es das Rückgrat der lokalen Inferenz ist. Sein Decode ist wirklich gut gebaut (quantisierte Integer-Kernels, kein FP16-Umweg). Aber universell zu bleiben heißt, dass es sich nicht auf die Eigenheiten eines einzelnen Chips stützen kann, also bleiben die nativen FP4-Tensor-Cores der 5090 ungenutzt.
Die eine Consumer-Karte mit nativer FP4-Hardware hatte also keine Engine, die natives FP4 sprach. Diese 30B-MoE-Modelle passen quantisiert bequem in 32 GB, und die Speicherbandbreite sagt, dass sie mit über 250 tok/s dekodieren sollten. Niemand lieferte das. Also habe ich das Ding gebaut, das es tut.
Was NVFP4 dir wirklich bringt#
NVFP4 ist das native Gewichtsformat für Blackwells FP4-Tensor-Cores: 4-Bit-Gleitkomma mit einem Skalierungsfaktor pro Block, direkt exportiert aus NVIDIAs Model Optimizer oder llm-compressor.
Hier ist die eine Tatsache, die es wichtig macht. Die Decode-Geschwindigkeit auf einer einzelnen GPU ist fast vollständig ein Problem der Speicherbandbreite: Jedes Token, das du erzeugst, muss die aktiven Gewichte durch den Chip schleppen. Die Bytes pro Gewicht zu halbieren (FP4 gegenüber FP8) oder zu vierteln (FP4 gegenüber FP16) verschiebt die Decke um denselben Faktor. Weniger Bytes zu bewegen, mehr Tokens pro Sekunde. Das ist der ganze Trick.
Der Haken ist der Teil, den dir niemand abnimmt: Für sm_120 gibt es keine fertigen
FP4-Matrix-Kernels. Wenn du das willst, schreibst du das GEMM selbst, in imps Fall
mma.sync mxf4nvf4 mit Block-Scaling, aufgebaut auf
CUTLASS, weil die Kernel-Designs von Hopper und B200 auf diesem Chip schlicht nicht laufen
können.
Die Zahlen#
Einzelne RTX 5090, Greedy Decoding, CUDA 13.3, CUDA Graphs an. Jede Zahl hier ist in BENCHMARKS.md datiert und an einen Commit gebunden, mit dem exakten Befehl zum Reproduzieren.
ec9145b3, ein Modell pro Prozess, 10 Wiederholungen. Treiber 610.47, wie von imps Roofline-Läufen am 2026-06-07 und 2026-06-10 geloggt; die Streuung pro Wiederholung wurde nicht erfasst.Auf diesem Chart gibt es aus einem einfachen Grund keine „vs.“-Spalte: Auf sm_120 gibt es
nichts zum Vergleichen. vLLMs NVFP4-Pfad braucht tcgen05, und llama.cpp hat gar keine
native NVFP4-Unterstützung. Natives NVFP4-Decode auf Consumer-Blackwell ist im Moment ein
Feld mit einem Teilnehmer.
Wo es doch einen fairen Vergleich gibt, nämlich bei dense GGUF, dem Heimspiel von
llama.cpp, dekodiert imp beide gemessenen dense Modelle
37 % bis 72 % schneller als llama.cpp: Qwen3-8B Q8_0 mit 274,4 tok/s gegenüber 159,7,
Qwen3-14B Q6_K mit 155,4 gegenüber 113,7 (2026-05-29, llama.cpp-Commit 19e92c3,
CUDA 12.8, Full Offload, Flash Attention an; Treiber nicht geloggt). Der Trick ist ein
kleiner: GGUF-Gewichte werden beim Laden einmal in FP4 konvertiert, der heiße Decode-Pfad
streamt also Sub-Byte-Gewichte, während Prefill die Quelle in voller Präzision behält.
Wo imp verliert#
Benchmarks, die nur Siege zeigen, sind Werbung. Hier ist also die ehrliche Liste, die erfreulicherweise kürzer geworden ist, seit ich diesen Post zum ersten Mal entworfen habe, weil Prefill die Schwachstelle war und Prefill die Aufmerksamkeit bekommen hat:
- GGUF-Prefill war früher ein klarer Verlust; jetzt ist es ungefähr ausgeglichen. Ein neuer INT8-Prefill-Pfad (Standard seit #617) hob den Durchsatz pro Modell um +36 % bis +151 %. imp liegt jetzt bei MoE (Qwen3-30B-A3B, +7 %) und dense (Qwen3-14B, +1,5 %) knapp vor llama.cpp und liegt nur bei Gemma-4-26B (1,20×) und einem Hybridmodell (1,55×) zurück.
- NVFP4-Prefill ist praktisch gleichauf. Die Überarbeitung des Attention-Kernels
(#687) brachte MoE-Long-Context-Prefill vor vLLM und verringerte den dense-Abstand von
1,27× auf 1,04×. Um präzise zu sein, was das schlägt: Auf
sm_120läuft vLLM auf einem Fallback-Pfad, weil seine tcgen05-NVFP4-Kernels auf Consumer-Blackwell nicht laufen, das ist also ein Vorsprung vor vLLMs Fallback, nicht vor seinem optimierten Rechenzentrums-Pfad. Der eine Überlebende ist dense Long-Context-Prefill, das um etwa 4 % verliert. - Qwen3.6-35B-GGUF-Decode verliert noch ~31 % gegen llama.cpp, strukturelle Kosten des speziellen Attention-Designs dieses Modells, die FP4-Gewichte nicht wettmachen können.
- Batched Durchsatz in der Summe unter Parallelität ist nicht imps Achse. Jede Zahl hier ist Single-Stream, Batch 1; bei vielen parallelen Requests liegen Engines wie vLLM vorn, und genau dafür sind sie gebaut.
- Es ist experimentell, Single-GPU, Single-Author. llama.cpp bleibt die richtige Wahl, wenn du Reife und Universalität willst; vLLM, wenn du auf Rechenzentrumskarten batchst. imp beantwortet genau eine Frage: Wie schnell kann eine einzelne 5090 sein?
Der Teil, den ich immer noch leicht absurd finde#
imp umfasst rund 97k Zeilen C++20 und CUDA (GGUF- und SafeTensors-Loader, ein BPE-Tokenizer, ein Paged KV-Cache, der CUTLASS-NVFP4-Dispatch, die Attention-Kernels, MoE-Routing, ein OpenAI- und Anthropic-kompatibler Server), und jede Zeile davon wurde von Claude Code geschrieben. Mein Job ist die Architektur, die Modellauswahl, das Benchmarking und die Richtung. Der Agent schreibt den Code. Wir sind bei 1.000+ Commits. Wie sich dieser Workflow in dieser Größenordnung schlägt, ist eine Geschichte für einen eigenen Post.
Wenn du eine 5090 hast und zusehen willst, wie es läuft: Alles kommt als Docker-Images auf GHCR, kein lokales CUDA-Toolkit nötig. Das Repo ist github.com/kekzl/imp: MIT, experimentell und ganz klar eine Wette auf eine einzige Architektur.