# 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. Source: https://rfriedmann.de/de/blog/serving-30b-models-rtx-5090/ · English: https://rfriedmann.de/blog/serving-30b-models-rtx-5090/ Published: 2026-06-02 · Track: log · Level: Advanced 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](https://github.com/kekzl/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)

Consumer-Blackwell - RTX 5090 (sm_120a)

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 `tcgen05` voraus, 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](https://github.com/kekzl/imp/blob/main/docs/BENCHMARKS.md) datiert und an einen Commit gebunden, mit dem exakten Befehl zum Reproduzieren.
NVFP4-Decode-Durchsatz - einzelne RTX 5090 (tok/s, Single-Stream, Batch 1, tg256)
[diagram omitted — see the page for the chart]
Natives NVFP4-Decode auf Consumer-Blackwell, Single-Stream (Batch 1), greedy, CUDA 13.3. tg256 = 256 erzeugte Tokens bei kurzem Kontext. Gemessen laut BENCHMARKS.md: 2026-06-09, Commit 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_120` lä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](https://claude.com/product/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](https://github.com/kekzl/imp/pkgs/container/imp), kein lokales CUDA-Toolkit nötig. Das Repo ist [github.com/kekzl/imp](https://github.com/kekzl/imp): MIT, experimentell und ganz klar eine Wette auf eine einzige Architektur.