11. November 2026 · VRAMfarm-Team
Wie viel VRAM brauche ich? Tabelle für LLMs, Flux, Wan-2.2-Video und Training
Ein Chatmodell mit 7–8B passt in 4 Bit auf eine 12-GB-Karte, ein 32B-Modell braucht 24 GB, und Llama 3.3 70B belegt allein mit seinen Gewichten rund 43 GB, realistisch sind also mindestens 48 GB. Bildmodelle liegen zwischen 10 GB (SDXL) und 24 GB (Qwen-Image in fp8), Wan-2.2-Video braucht 22–48 GB. Auf denselben Schätzungen beruht die VRAM-Auswahl auf der Startseite, und mit der Formel dahinter können Sie jedes Modell selbst nachrechnen.
Die Formel: Gewichte, KV-Cache und Overhead
Während ein Modell läuft, liegen drei Dinge im Grafikspeicher:
VRAM ≈ Parameter × Bytes pro Parameter + KV-Cache (oder Aktivierungen) + 1–2 GB Overhead
Der erste Teil sind die Gewichte. Eine Milliarde Parameter zu je 2 Bytes ergibt 2 GB, ein 8B-Modell in fp16 braucht also rund 16 GB, bevor es auch nur ein Wort verarbeitet hat. Wie viele Bytes ein Parameter belegt, hängt von der Präzision ab:
| Präzision | Bytes pro Parameter | 8B-Modell | 32B-Modell | 70B-Modell | Qualität |
|---|---|---|---|---|---|
| fp32 | 4 | 32 GB | 131 GB | 282 GB | Nur fürs Training, niemand betreibt Modelle in fp32 |
| fp16 / bf16 | 2 | 16 GB | 66 GB | 141 GB | Die Referenz |
| fp8 / int8 | 1 | 8 GB | 33 GB | 71 GB | Sehr nah an fp16 |
| 4 Bit (Q4_K_M, AWQ, GPTQ) | 0,55–0,6 | 5 GB | 20 GB | 43 GB | Kleiner Verlust, für Chat in Ordnung |
| 2–3 Bit | 0,3–0,4 | 3 GB | 12 GB | 25 GB | Deutlich schlechter, letzter Ausweg |
Der zweite Teil hängt davon ab, was das Modell tut. Bei einem Sprachmodell ist es der KV-Cache: Das Modell speichert Keys und Values für jedes Token der Unterhaltung, und dieser Speicher wächst mit der Kontextlänge. Bei Bild- und Videomodellen sind es die Aktivierungen: Zwischentensoren, die mit Auflösung, Anzahl der Frames und Batch-Größe wachsen.
Der dritte Teil sind CUDA-Kontext, Puffer des Frameworks und Speicherfragmentierung. Planen Sie 1–2 GB ein, bei vLLM mehr, denn es reserviert standardmäßig gleich zu Beginn 90 % der Karte.
Mit Quantisierung bringen die meisten größere Modelle auf kleinere Karten. fp8 halbiert die Gewichte praktisch ohne sichtbaren Unterschied und ist in ComfyUI der Standard für Flux, Qwen-Image und Wan. 4 Bit halbiert sie noch einmal. Für Chat und Zusammenfassungen liefert ein 32B-Modell in 4 Bit (rund 20 GB) meist bessere Antworten als ein 8B-Modell in fp16, das fast genauso viel Speicher belegt. Bei Code und Mathematik fällt der Verlust in kleinen Modellen eher auf. Unter 4 Bit sinkt die Qualität schnell.
Ein Detail zur Hardware: fp8 wird ab der Ada-Generation nativ berechnet (RTX-40- und RTX-50-Serie, L40S, H100, B200). Ampere-Karten (RTX 3090, RTX A6000, A100) können fp8-Gewichte laden, rechnen aber in fp16. Sie sparen also Speicher, gewinnen aber keine Geschwindigkeit.
Sprachmodelle: von 8B bis 235B
Die Werte sind Näherungen: Gewichte plus Arbeitspuffer bei kurzem Kontext. Langer Kontext kommt hinzu, siehe den Abschnitt zum KV-Cache weiter unten. Die Spalte „4 Bit“ entspricht dem, was unsere Auswahl anzeigt, denn so betreiben die meisten diese Modelle auf einer Karte.
| Modell | fp16 | fp8 | 4 Bit | Karte für 4 Bit | Karte für fp8 |
|---|---|---|---|---|---|
| Qwen3 8B, Llama 3.1 8B | 17 GB | 9 GB | 7 GB | 12 GB: RTX 3060 | 16 GB: RTX 4060 Ti, RTX 4080 |
| Qwen3 14B | 30 GB | 15 GB | 10 GB | 16 GB: RTX 4060 Ti, RTX 5070 Ti | 24 GB: RTX 3090, RTX 4090 |
| Qwen3 32B | 66 GB | 33 GB | 21 GB | 24 GB: RTX 3090, RTX 4090 | 48 GB: RTX A6000, L40S |
| Llama 3.3 70B | 141 GB | 71 GB | 43 GB | 48 GB: RTX A6000, L40, L40S | 80–96 GB: H100, RTX PRO 6000 |
| Qwen3 235B-A22B (MoE) | 470 GB | 235 GB | 136 GB | 192 GB: B200 oder 2 × A100 / H100 | 4 × H100 oder 2 × B200 |
Ein paar Hinweise zum Lesen:
- 24 GB reichen für ein 32B-Modell, mit kurzem Kontext. Ein 32B-Modell in 4 Bit lässt auf einer 24-GB-Karte 2–3 GB für den KV-Cache, genug für etwa 8.000–10.000 Tokens. Die RTX 5090 mit 32 GB gibt demselben Modell Platz für rund 30.000–40.000, je nach Quantisierung und den eigenen Puffern der Laufzeitumgebung.
- 70B auf einer Karte heißt 48 GB oder mehr. Auf 48 GB läuft ein 70B-Modell in 4 Bit mit 8.000–12.000 Tokens Kontext, mit einem 8-Bit-Cache etwa doppelt so viel. Für lange Dokumente, mehrere Nutzer gleichzeitig oder den Betrieb mit vLLM nehmen Sie eine A100 oder H100 mit 80 GB.
- Die H200 mit 141 GB scheint für ein 136-GB-Modell zu passen, ist aber zu knapp. Nach dem CUDA-Kontext bleibt kaum etwas für den Cache. Nehmen Sie eine B200 oder zwei Karten mit 80 GB.
- MoE-Modelle brauchen alle Experten im Speicher. Qwen3 235B-A22B aktiviert pro Token 22B Parameter und erzeugt Text deshalb etwa so schnell wie ein dichtes Modell mit 22–30B, braucht aber den Speicher eines 235B-Modells.
Die Geschwindigkeit ist eine eigene Frage. Für jedes erzeugte Token wird das ganze Modell aus dem Speicher gelesen. Eine grobe Obergrenze für Tokens pro Sekunde ist deshalb die Speicherbandbreite geteilt durch die Modellgröße. Eine RTX 4090 (1.008 GB/s) kommt mit einem 20-GB-Modell auf höchstens etwa 50 Tokens pro Sekunde, in der Praxis etwas weniger. Deshalb wirkt eine H100 mit 3.350 GB/s mit demselben Modell so viel schneller.
Bild- und Videomodelle
Bild- und Videomodelle laufen in ComfyUI meist in fp8, und ComfyUI schiebt Text-Encoder und VAE je nach Bedarf in den VRAM und wieder heraus. „Mindestens“ heißt hier: läuft bei 1024 × 1024 (oder 720p-Video) ohne Fehler. Die empfohlene Karte lässt Luft für LoRAs, ControlNet und höhere Auflösungen. Verstehen Sie die Werte als Schätzung für einen typischen Workflow: Auflösung, Anzahl der Frames und die Offloading-Einstellungen von ComfyUI können sie um mehrere Gigabyte in beide Richtungen verschieben.
| Modell | Präzision | VRAM | Mindestkarte | Komfortable Karte |
|---|---|---|---|---|
| SDXL | fp16 | ~10 GB | 12 GB: RTX 3060 | 16 GB: RTX 4060 Ti, RTX 4080 |
| Flux.1 dev | fp8 | ~16 GB | 16 GB: RTX 4080, RTX 5070 Ti | 24 GB: RTX 4090 (auch bf16) |
| Qwen-Image, Qwen Image Edit | fp8 | ~24 GB | 24 GB: RTX 3090, RTX 4090 | 32–48 GB: RTX 5090, L40S |
| HiDream | fp8 | ~24 GB | 24 GB: RTX 3090, RTX 4090 | 32 GB: RTX 5090 |
| Wan 2.2 5B (Text/Bild zu Video) | bf16 | ~22 GB bei 720p | 24 GB: RTX 4090 | 32 GB: RTX 5090 |
| Wan 2.2 14B (Text/Bild zu Video) | fp8 | ~30 GB | 32 GB: RTX 5090 | 48 GB: L40S, RTX A6000 |
Bei Video liegen „passt“ und „passt bequem“ am weitesten auseinander. Jede zusätzliche Sekunde bringt mehr Frames, und jeder Frame bringt mehr Aktivierungen. Wan 2.2 14B in fp8 braucht für einen 5-Sekunden-Clip in 720p etwa 30 GB: Eine RTX 5090 mit 32 GB schafft das, aber längere Clips oder höhere Auflösung zwingen Sie auf 48 GB. Deshalb verlangt unsere fertige App für Wan 2.2 14B eine 48-GB-Karte, die 5B-App eine mit 24 GB.
Es gibt GGUF-Quantisierungen (Q4, Q5) von Flux und Qwen-Image, mit denen diese Modelle auf Karten mit 8–12 GB laufen, auf Kosten langsamerer Schritte und einiger Details. Für ein paar Bilder ist das in Ordnung; bei echter Arbeit macht sich der zusätzliche Speicher in gesparter Zeit bezahlt. Der GPU-Ratgeber für Flux, SDXL und ComfyUI geht Karte für Karte durch.
Sprache und Training
Modelle für Spracherkennung und Sprachausgabe sind klein. Training braucht dagegen viel mehr Speicher als der Betrieb desselben Modells, weil Gradienten und Optimizer-Zustände neben den Gewichten liegen.
| Aufgabe | VRAM | Karte |
|---|---|---|
| Whisper large-v3 (fp16) | ~10 GB (int8 mit faster-whisper: wenige GB) | 12 GB: RTX 3060 |
| Chatterbox, Qwen3-TTS, VoxCPM | 6–8 GB | 12 GB: RTX 3060 |
| SDXL-LoRA | 12–16 GB | 16–24 GB |
| Flux-LoRA | ~24 GB | 24 GB: RTX 3090, RTX 4090 |
| QLoRA, 8B-Modell | 10–16 GB | 16–24 GB |
| QLoRA, 32B-Modell | 24–32 GB | 48 GB |
| QLoRA, 70B-Modell | ~48 GB bei kurzen Sequenzen | 80 GB: A100, H100 |
| Volles Fine-Tuning, 8B-Modell | ~70 GB mit 8-Bit-Optimizer und Gradient Checkpointing | 80-GB-Karte oder mehrere |
Die Zeile zum vollen Fine-Tuning braucht eine Erklärung. Mit dem üblichen AdamW-Optimizer in Mixed Precision kostet jeder Parameter rund 16 Bytes: bf16-Gewichte (2), Gradienten (2), eine fp32-Masterkopie (4) und zwei Optimizer-Zustände (8). Bei 8B Parametern sind das etwa 128 GB vor den Aktivierungen, also zwei oder mehr Karten mit 80 GB, eine H200 oder eine B200. Ein 8-Bit-Optimizer und Gradient Checkpointing drücken das auf etwa 70 GB, je nach Sequenzlänge und Trainer, und das passt auf eine einzelne A100 oder H100. QLoRA umgeht fast alles davon: Das Basismodell bleibt eingefroren in 4 Bit, trainiert werden nur kleine Adapter-Matrizen.
Warum ein Modell, das passt, bei langem Kontext trotzdem abstürzt
Das ist die häufigste Überraschung: Das Modell lädt, beantwortet die ersten Fragen und bricht dann mit „CUDA out of memory“ ab, sobald Sie ein langes Dokument einfügen. Die Gewichte haben gepasst. Der KV-Cache nicht.
Der Cache pro Token beträgt 2 × Schichten × KV-Heads × Head-Größe × Bytes. In fp16 ergibt das:
| Modell | KV-Cache pro Token | 8.000 Tokens | 32.000 Tokens | 128.000 Tokens |
|---|---|---|---|---|
| Qwen3 8B | 0,15 MB | 1,2 GB | 4,8 GB | 19 GB |
| Qwen3 32B | 0,26 MB | 2,1 GB | 8,6 GB | 34 GB |
| Llama 3.3 70B | 0,33 MB | 2,7 GB | 10,7 GB | 43 GB |
Ein 70B-Modell in 4 Bit läuft auf einer 48-GB-Karte bei 8.000 Tokens also problemlos und stößt irgendwo bei 10.000–12.000 an die Grenze. Beim beworbenen Kontext von 128.000 Tokens ist allein der Cache so groß wie die Gewichte. Bedienen Sie mehrere Nutzer, vervielfacht sich der Cache mit der Zahl der parallelen Unterhaltungen.
So lösen Sie das ohne größere Karte:
- Kontext begrenzen. In vLLM setzen Sie
--max-model-len 16384. vLLM startet gar nicht erst, wenn der gewünschte Kontext nicht passt, und das ist besser als ein späterer Absturz. In Ollama entscheidet die Kontextlänge (num_ctx) über den Speicher; setzen Sie sie also bewusst, statt sich auf den Standardwert zu verlassen, der sich zwischen Versionen geändert hat. - Cache quantisieren.
--kv-cache-dtype fp8in vLLM oder-ctk q8_0 -ctv q8_0in llama.cpp (mit eingeschalteter Flash Attention) halbiert den Cache, ohne die Antworten nennenswert zu verändern. - Parallele Anfragen begrenzen, wenn Sie eine API betreiben: weniger gleichzeitige Unterhaltungen, weniger Cache.
Wenn Sie den langen Kontext jeden Tag brauchen, ist die nächstgrößere Karte meist die günstigere Lösung: eine 80-GB-Karte für 70B oder eine RTX 5090 mit 32 GB statt 24 GB für 32B.
Die Karte nach der Zahl wählen
Nehmen Sie den Wert aus den Tabellen, rechnen Sie 10–20 % Reserve dazu und wählen Sie die kleinste Karte darüber. Karten gibt es in festen Stufen: 10–12 GB, 16 GB, 24 GB, 32 GB, 48 GB, 80 GB, 96 GB, 141 GB und 192 GB. Innerhalb einer Stufe geht es um Geschwindigkeit, nicht darum, was überhaupt läuft: Eine RTX 3090 und eine RTX 4090 haben beide 24 GB. Die 4090 erzeugt Bilder etwa 1,6- bis 2,5-mal so schnell, LLM-Text aber nur etwas schneller, weil die Speicherbandbreite ähnlich ist (936 gegenüber 1.008 GB/s). Vergleichen Sie die Stundenpreise, ab 0,30 € und ab 0,59 €, auf der Preisseite.
Wenn Sie unsicher sind, nehmen Sie eine Stufe größer, als Sie denken. Abgerechnet wird minutengenau: Eine zu große Karte kostet Sie für den Test ein paar Cent, eine zu kleine einen Abend voller Out-of-Memory-Fehler.