LLM-VRAM-Rechner — kann ich dieses LLM lokal ausführen?

Ermittle, wie viel GPU-Speicher ein lokales LLM für deine Quantisierung und Kontextlänge braucht, ob es auf deine GPU oder deinen Mac passt und wie schnell es läuft.

Modell

Quantisierung

Der übliche Standard: bestes Verhältnis von Größe und Qualität.

Kontextlänge (Tokens)

Parallele Sequenzen

1 für einen persönlichen Chat

KV-Cache-Typ

8,03B Parameter. Attention: 32 Layer x 8 KV-Heads x 128 Dim.

Benötigter Speicher gesamt

6.46 GB

Modellgewichte

4.57 GB

4.89 Bit/Gewicht

KV-Cache

1.00 GB

8.192 Tokens x 1

Laufzeit-Overhead

0.89 GB

0,75 GB + 3 % der Gewichte

Dunkel: Gewichte · Blau: KV-Cache · Grau: Overhead. GB bedeutet hier GiB (1024³ Byte), die Einheit, in der GPU-Speicher verkauft wird.

GPU / Mac	Nutzbar	Ergebnis	Geschätzte Geschw.
RTX 3060 12 GB 360 GB/s	12 GB	Passt	~39 tok/s
RTX 4060 Ti 16 GB 288 GB/s	16 GB	Passt	~31 tok/s
RTX 4070 Super 12 GB 504 GB/s	12 GB	Passt	~55 tok/s
RTX 4080 Super 16 GB 736 GB/s	16 GB	Passt	~80 tok/s
RTX 5080 16 GB 960 GB/s	16 GB	Passt	~104 tok/s
RTX 3090 24 GB 936 GB/s	24 GB	Passt	~102 tok/s
RTX 4090 24 GB 1008 GB/s	24 GB	Passt	~110 tok/s
RTX 5090 32 GB 1792 GB/s	32 GB	Passt	~195 tok/s
Radeon RX 7900 XTX 24 GB 960 GB/s	24 GB	Passt	~104 tok/s
RTX 6000 Ada 48 GB 960 GB/s	48 GB	Passt	~104 tok/s
A100 40 GB 1555 GB/s	40 GB	Passt	~169 tok/s
A100 80 GB (SXM) 2039 GB/s	80 GB	Passt	~222 tok/s
H100 80 GB (SXM) 3350 GB/s	80 GB	Passt	~364 tok/s
H200 141 GB 4800 GB/s	141 GB	Passt	~522 tok/s
Ryzen AI Max+ 395 (96 GB to GPU) 256 GB/s	96 GB	Passt	~28 tok/s
Mac M2/M3/M4, 16 GB 100 GB/s	10.7 GB	Passt	~11 tok/s
Mac M3/M4, 24 GB 120 GB/s	16.1 GB	Passt	~13 tok/s
Mac M4 Pro, 48 GB 273 GB/s	36 GB	Passt	~30 tok/s
Mac M4 Max, 64 GB 546 GB/s	48 GB	Passt	~59 tok/s
Mac M4 Max, 128 GB 546 GB/s	96 GB	Passt	~59 tok/s
Mac M2 Ultra, 192 GB 800 GB/s	144 GB	Passt	~87 tok/s
Mac M3 Ultra, 512 GB 819 GB/s	384 GB	Passt	~89 tok/s

„Knapp“ heißt innerhalb von 10 % des Limits: Es lädt eventuell, aber ein Browser oder eine andere App kann es darüber schieben. Die Geschwindigkeit gilt für die Generierung mit einem Nutzer, geschätzt als 65 % der Speicherbandbreite geteilt durch die pro Token gelesenen Bytes; die Prompt-Verarbeitung ist schneller, und echte Werte hängen von der Runtime ab. Apple Silicon kann der GPU standardmäßig etwa zwei Drittel (bis 36 GB) oder drei Viertel (größer) des RAM zuweisen.

Wird in deinem Browser berechnet. Nichts, was du eingibst, wird irgendwohin gesendet. Alle kostenlosen Tools ansehen.

Ein Problem gefunden oder etwas, das besser sein könnte? Wir lesen jede Nachricht und beheben Fehler schnell.

Dieser LLM-VRAM-Rechner beantwortet die Frage „Kann ich dieses LLM lokal ausführen?“, indem er schätzt, wie viel Speicher ein Modell auf deiner GPU oder deinem Mac braucht: die Gewichte bei deiner gewählten Quantisierung, den KV-Cache für deine Kontextlänge und den Laufzeit-Overhead. Wähle ein beliebtes offenes Modell oder gib eine Parameterzahl ein, wähle eine Quantisierung wie Q4_K_M und sieh die Summe neben der Bewertung passt, knapp oder passt nicht für gängige Grafikkarten und Apple-Silicon-Rechner, jeweils mit einer groben Generierungsgeschwindigkeit.

Die meisten Schnellschätzungen multiplizieren Parameter mit Bytes pro Gewicht und hören dann auf – das stimmt bei kurzen Prompts ungefähr und liegt bei langen weit daneben. Ein Llama-3.1-8B-Modell in Q4_K_M braucht etwa 4,6 GB für die Gewichte, aber sein KV-Cache wächst von 1 GB bei 8K Kontext auf 16 GB bei 128K. Die Voreinstellungen hier enthalten den echten Attention-Aufbau jedes Modells (Grouped-Query-Heads, Sliding Windows, die Latent Attention von DeepSeek), sodass der KV-Cache so bemessen wird, wie llama.cpp und vLLM ihn tatsächlich reservieren. Die Formeln stehen unten, und die Berechnung ist mit Unit-Tests gegen echte GGUF-Dateigrößen abgesichert.

So funktioniert’s

Wähle ein Modell aus der Liste oder Eigenes, um eine Parameterzahl einzugeben (und für einen exakten KV-Cache die Werte für Layer, KV-Heads und Head-Dimension aus der config.json des Modells).
Wähle die Quantisierung, die du herunterladen willst. Q4_K_M ist der übliche Ausgangspunkt für GGUF-Modelle in llama.cpp, Ollama und LM Studio.
Lege die Kontextlänge fest, die du tatsächlich nutzen wirst, und die Anzahl paralleler Sequenzen (1 für den persönlichen Chat, mehr für einen Server).
Lies die Summe und die Aufschlüsselung und dann die Bewertung für jede GPU bzw. jeden Mac. Knapp heißt: innerhalb von 10 % des Limits.
Passt es nicht, versuch eine kleinere Quantisierung, einen kürzeren Kontext, einen Q8_0-KV-Cache oder ein Modell mit weniger Parametern.

Häufige Fragen

Wie viel VRAM brauche ich für ein 8B-Modell?

Etwa 6,5 GB für Llama 3.1 8B in Q4_K_M mit 8K Kontext: 4,6 GB Gewichte, 1 GB KV-Cache und unter 1 GB Overhead. Das passt auf eine 8-GB-GPU und bequem auf eine RTX 3060 mit 12 GB. In FP16 braucht dasselbe Modell etwa 17 GB, also eine 24-GB-Karte. Die Kontextlänge zählt: Beim vollen Kontext von 128K ist allein der KV-Cache 16 GB groß.

Kann ich ein 70B-Modell auf einer 24-GB-GPU ausführen?

Nicht komplett im VRAM. Llama 3.3 70B in Q4_K_M braucht etwa 40 GB für die Gewichte und bei 8K Kontext rund 45 GB insgesamt; selbst Q2_K braucht etwa 30 GB. Optionen sind zwei 24-GB-GPUs, eine 48-GB-Karte, ein Mac mit 64 GB oder mehr Unified Memory oder das Auslagern eines Teils des Modells in den Arbeitsspeicher, was funktioniert, aber um ein Mehrfaches langsamer ist.

Was ist der KV-Cache, und warum wächst er mit dem Kontext?

Während der Generierung speichert das Modell für jedes vorherige Token in jedem Layer einen Key- und einen Value-Vektor, damit es sie nicht für jedes neue Token neu berechnen muss. Seine Größe ist 2 x Layer x KV-Heads x Head-Dimension x Kontextlänge x Bytes pro Wert. Für Llama 3.1 8B (32 Layer, 8 KV-Heads, Head-Dimension 128, FP16) sind das 128 KB pro Token: 1 GB bei 8K Tokens und 16 GB bei 128K. Modelle mit Grouped-Query Attention, Sliding-Window-Layern (Gemma) oder Latent Attention (DeepSeek) brauchen weit weniger.

Welche Quantisierung sollte ich verwenden?

Q4_K_M ist der Standardkompromiss: etwa ein Drittel der FP16-Größe bei geringem Qualitätsverlust für die meisten Anwendungen. Nimm Q5_K_M oder Q6_K, wenn sie passen, Q8_0, wenn du praktisch identische Ergebnisse zum Original willst, und vermeide Q3 und Q2 bei Modellen unter etwa 30B Parametern, wo der Qualitätsverlust deutlich wird. Ein größeres Modell in Q4 schlägt meist ein kleineres Modell in Q8 bei gleicher Dateigröße.

Ist ein Mac oder eine NVIDIA-GPU besser für lokale LLMs?

Auf einen Mac passen größere Modelle; eine NVIDIA-GPU führt die passenden schneller aus. Apple Silicon teilt sich einen Speicherpool zwischen CPU und GPU, sodass ein Mac mit 128 GB ein 70B-Modell halten kann, das auf keine Consumer-Grafikkarte passt – seine Speicherbandbreite (546 GB/s bei einem M4 Max) ist aber nur etwa halb so hoch wie die 1.008 GB/s einer RTX 4090, und die Generierungsgeschwindigkeit skaliert mit der Bandbreite. Standardmäßig lässt macOS die GPU auf Rechnern bis 36 GB etwa zwei Drittel des Arbeitsspeichers nutzen und auf größeren etwa drei Viertel.

Wie genau ist die Schätzung der Tokens pro Sekunde?

Sie ist ein grober Richtwert, bei der Generierung für einen einzelnen Nutzer typischerweise auf 30 % genau. Für jedes generierte Token müssen die aktiven Gewichte und der KV-Cache einmal aus dem Speicher gelesen werden, die Geschwindigkeit ist also etwa Speicherbandbreite geteilt durch Bytes pro Token; das Tool nimmt an, dass 65 % der Spitzenbandbreite erreicht werden. Die Prompt-Verarbeitung ist rechengebunden und viel schneller, MoE-Modelle bringen Routing-Overhead mit, und Laufzeitumgebung, Treiber und Einstellungen verschieben die echten Zahlen.

Die Formeln dieses Rechners

Gesamtspeicher = Modellgewichte + KV-Cache + Laufzeit-Overhead. Alle Größen sind in GiB (1.024³ Byte), der Einheit, in der GPU-Speicher verkauft wird: Eine RTX 4090 mit „24 GB“ hat 24 GiB.

Gewichte = Parameter x Bits pro Gewicht / 8. Bei GGUF-K-Quants sind die Bits pro Gewicht effektive Werte, gemessen an echten Dateien, weil jeder Quant-Typ Genauigkeiten über die Tensoren mischt: Q8_0 8,5, Q6_K 6,57, Q5_K_M 5,70, Q4_K_M 4,89, IQ4_XS 4,43, Q3_K_M 4,00, Q2_K 3,17 (aus den GGUF-Dateien von Llama 3.1 8B; größere Modelle fallen bis zu etwa 5 % kleiner aus). AWQ und GPTQ verwenden 4-Bit-Gewichte mit einem Skalierungsfaktor pro 128 Gewichte (etwa 4,16 Bit) und behalten Embeddings und Ausgabeschicht in 16 Bit; gpt-oss liefert seine Expertengewichte in MXFP4 (4,25 Bit) aus, Attention und Embeddings in BF16.

KV-Cache = 2 x Layer x KV-Heads x Head-Dimension x Tokens x Bytes pro Wert x parallele Sequenzen. Grouped-Query Attention ist der Grund, warum kv_heads (8 bei Llama 3 70B) viel kleiner ist als die Zahl der Attention-Heads (64). Sliding-Window-Layer speichern höchstens ihr Fenster (1.024 Tokens bei Gemma 3, 128 bei der Hälfte der Layer von gpt-oss). DeepSeek V3 und R1 speichern pro Layer und Token einen Latent-Vektor mit 576 Werten statt vollständiger Keys und Values. FP16 braucht 2 Byte pro Wert, ein Q8_0-Cache etwa 1,06 und Q4_0 etwa 0,56.

Overhead = 0,75 GiB + 3 % der Gewichte, für den CUDA- oder Metal-Kontext und Rechenpuffer. Echte Laufzeitumgebungen weichen um einige hundert Megabyte ab. Geschwindigkeit = Speicherbandbreite x 0,65 / (Bytes der aktiven Gewichte + KV-Cache einer Sequenz).

Quantisierungsgrößen auf einen Blick

Nur Gewichte, aus diesem Rechner, für Llama 3.1 8B und Llama 3.3 70B:

• FP16 / BF16: 15,0 GB und 131,5 GB

• Q8_0: 7,9 GB und 69,9 GB

• Q6_K: 6,1 GB und 54,0 GB

• Q5_K_M: 5,3 GB und 46,8 GB

• Q4_K_M: 4,6 GB und 40,2 GB

• Q3_K_M: 3,7 GB und 32,9 GB

• Q2_K: 3,0 GB und 26,1 GB

Addiere den KV-Cache für deinen Kontext und etwa 1 GB Overhead, dann hast du, was die GPU halten muss.

Mixture-of-Experts-Modelle: Speicherbedarf eines großen, Tempo eines kleinen Modells

Ein Mixture-of-Experts-Modell (MoE) wie Qwen3 30B-A3B, Mixtral 8x7B, gpt-oss oder DeepSeek R1 enthält viele Experten-Teilnetze, nutzt für jedes Token aber nur wenige davon. Alle müssen im Speicher liegen, der Speicherbedarf richtet sich also nach der Gesamtzahl der Parameter. Die Geschwindigkeit richtet sich nach den aktiven Parametern, weil nur deren Gewichte pro Token gelesen werden.

Deshalb braucht Qwen3 30B-A3B in Q4_K_M etwa 19 GB, den Speicher eines dichten 30B-Modells, generiert Text aber im Tempo eines 3B-Modells. Und deshalb passen MoE-Modelle gut zu Macs und anderen Rechnern mit viel, aber langsamerem Speicher: Die Kapazität ist der Engpass, die Bandbreite weniger.

DeepSeek R1 mit 671B Parametern ist der Extremfall: etwa 380 GB in Q4_K_M, jenseits jedes einzelnen Consumer-Rechners, obwohl pro Token nur 37B Parameter aktiv sind.