Je hoeft niet elke prompt naar een cloud-API te sturen. In 2026 draaien serieuze taalmodellen op gewone gamehardware — als je weet wat VRAM doet en welk model bij welke kaart past. Dit is geen belofte van marketingfolders, maar wat de benchmarks werkelijk laten zien.

Wat VRAM écht bepaalt

Elke parameter in een taalmodel neemt geheugen in. Bij full precision (FP16) kost één miljard parameters ruwweg 2 GB VRAM. Een 7B-model vraagt dus al snel 14 GB — meer dan de meeste middenklasse GPU's hebben. Quantisatie is de reden dat lokaal draaien überhaupt haalbaar werd: door gewichten te comprimeren naar 4-bit integers (Q4) of 5-bit (Q5) halveer je het geheugenverbruik, met een kwaliteitsverlies dat in de praktijk zelden merkbaar is.

Het populairste formaat voor lokaal gebruik is GGUF, het standaardformaat van llama.cpp. De twee meest gebruikte kwantisatiepresetten zijn Q4_K_M (4-bit, medium-kwaliteitsbalans) en Q5_K_S (5-bit, iets scherper maar ~15% groter). Voor de meeste gebruikers is Q4_K_M het startpunt: de beste prijs-kwaliteitsverhouding in VRAM per outputkwaliteit.

Naast de modelgewichten zelf neemt de KV-cache ook geheugen in: de tijdelijke opslag van de "context" die het model bijhoudt tijdens het genereren. Bij een contextvenster van 8K tokens kan de KV-cache al 1–2 GB extra vragen. Hoe groter je context, hoe minder VRAM er overblijft voor de modellagen zelf — met merkbare snelheidsdaling als gevolg.

Een ander onderschat aspect is bandbreedte. Tokens per seconde worden niet alleen bepaald door hoeveel VRAM je hebt, maar hoe snel die geheugenbus werkt. Een RTX 4090 haalt 1.008 GB/s; de 4070 slechts 504 GB/s. Dat verschil vertaalt zich rechtstreeks in snelheidsverschillen, ook bij identieke VRAM-bezetting.

7B op 8–12 GB: waar het voor bijna iedereen begint

Een RTX 4060 (8 GB), RTX 4070 (12 GB) of elk equivalent met minstens 8 GB VRAM is genoeg voor de gangbare 7B- en 8B-modellen. Llama 3.1 8B Instruct in Q4_K_M vraagt circa 5,5 GB VRAM en past ruim in de 8 GB-klasse. Op een RTX 4070 haalt llama.cpp typisch 55–70 tokens per seconde — vlot genoeg om de tekst bijna sneller te lezen dan die gegenereerd wordt.

Op de RTX 4060 met 8 GB VRAM loopt datzelfde model aan de rand: een contextvenster van 4K is comfortabel, 8K al krap. Schakel je over naar Q5_K_S, dan klim je naar 6,5 GB en heb je nauwelijks marge meer voor systeemgeheugen dat de GPU deelt.

Populaire keuzes in dit segment:

  • Llama 3.2 3B (Q4_K_M, ~2,0 GB) — extreem snel, 100+ tok/s op 8 GB, nuttiger dan zijn formaat doet vermoeden
  • Llama 3.1 8B Instruct (Q4_K_M, ~5,5 GB) — solide allesronder, 55–70 tok/s op RTX 4070
  • Mistral 7B v0.3 (Q4_K_M, ~5,1 GB) — sterk op code en instructie-taken
  • Qwen 2.5 7B Instruct (Q4_K_M, ~5,2 GB) — opvallend goed in meertalige taken inclusief Nederlands

Het 8 GB-segment heeft één harde grens: 13B-modellen in Q4_K_M vragen 8,5–9 GB. Op papier past een Q4-versie van Qwen 2.5 14B net niet volledig in 12 GB; in de praktijk werkt het op een 12 GB RTX 4070 op 4K context mits je niets anders open hebt staan.

13B en 32B: de middenklasse waar het interessant wordt

Met 16–24 GB VRAM opent zich een ander universum. De RTX 4070 Ti Super (16 GB), RTX 4080 (16 GB) en RTX 4090 (24 GB) behoren hier tot de meest gebruikte lokale AI-kaarten.

Op een 16 GB RTX 4080 draaien modellen zoals Qwen 2.5 14B (Q4_K_M, ~9,8 GB) met 8K context en nog ruimte over. Benchmarks tonen 42–55 tokens per seconde op die configuratie. Dat is comfortabel voor dagelijks gebruik: vertalingen, schrijftaken, codegeneratie — allemaal zonder merkbare vertraging.

Het interessantste model in de 24 GB-klasse is Qwen 2.5 32B Instruct. In Q4_K_M pakt het ~22,0 GB VRAM — het past net op een RTX 4090. Met een standaard contextvenster van 4K haalt llama.cpp hier 30–43 tokens per seconde. Dat is een kwantumsprong in redeneervermogens ten opzichte van de 7B-klasse, voor minder dan een fractie van de API-kosten.

De keerzijde: met 22 GB bezet door het model blijft er nauwelijks marge voor grotere context. Bij 32K tokens zakt de snelheid door KV-cache-druk naar 18–22 tok/s. Wie regelmatig met lange documenten werkt, loopt hier snel tegen een plafond aan.

Een RTX 4090 is de meest capabele consumentenkaart voor lokale AI — maar hij kan een 70B-model niet zelfstandig dragen. Dat is niet zijn falen; het is een fundamentele grens van 24 GB VRAM.

70B: de grens van een consumer-GPU

Hier wordt het interessant — en eerlijk gezegd ook iets pijnlijk. Llama 3.3 70B Instruct is een van de beste open modellen van dit moment, en het weegt in Q4_K_M 42–43 GB. Dat past simpelweg niet in 24 GB VRAM.

Er zijn drie opties voor wie dit model lokaal wil draaien:

  1. CPU-offload: een deel van de modellagen draait op RAM. llama.cpp ondersteunt dit via --n-gpu-layers. Met een RTX 4090 en 64 GB systeemgeheugen kun je 40–45 lagen in GPU laden en de rest in RAM offloaden. Resultaat: 3–8 tokens per seconde. Bruikbaar voor rustige taken, onaangenaam voor interactief gebruik.
  2. Dubbele GPU: twee RTX 4090's geven 48 GB VRAM gecombineerd, wat het model volledig in GPU-geheugen past. Met llama.cpp's tensor-parallellisme haal je hier 25–35 tokens per seconde. Prijs: €3.000–4.000 voor de twee kaarten en een platform dat dual-GPU ondersteunt.
  3. Workstation-kaart: een NVIDIA RTX 6000 Ada of RTX A6000 (48 GB ECC VRAM) draagt het model zonder truc. Snelheid is vergelijkbaar met de dual-4090-setup bij ~30 tok/s, maar in één kaart. Kostprijs: €7.000–10.000 tweedehands.

Een aanlokkelijk alternatief is een sterk gequantiseerd 70B-model in Q2_K of IQ3_XS — dat perst het model terug naar 25–28 GB. Op een RTX 4090 haalt het dan 15–22 tok/s zonder offload. De kwaliteitsdaling is bij redeneer-intensieve taken merkbaar; voor samenvatten of vertalen is het dikwijls acceptabel.

Voor wie het absolute maximum uit één kaart wil halen zonder 70B: Qwen 2.5 32B Q5_K_S (26 GB) staat conceptueel net boven de grens van de 4090, maar in Q4_K_M is het de beste keuze op een 24 GB-kaart in 2026. De afstand naar de 70B-klasse in redeneer- en codeertaken is kleiner geworden dan een jaar geleden.

Testbank — referentie-GPU's en gemeten snelheden

GPU VRAM Model Kwantisatie Tok/s (gen) Tool
RTX 4060 8 GB Llama 3.1 8B Q4_K_M ~40–50 Ollama
RTX 4070 12 GB Llama 3.1 8B Q4_K_M ~55–70 llama.cpp
RTX 4070 12 GB Qwen 2.5 14B Q4_K_M ~33–42 llama.cpp
RTX 4080 16 GB Qwen 2.5 14B Q4_K_M ~42–55 llama.cpp
RTX 4090 24 GB Qwen 2.5 32B Q4_K_M ~30–43 llama.cpp
RTX 4090 24 GB Llama 3.3 70B Q4_K_M + CPU-offload ~3–8 llama.cpp
2× RTX 4090 48 GB Llama 3.3 70B Q4_K_M ~25–35 llama.cpp
RTX 4090 24 GB Llama 3.3 70B IQ3_XS (~28 GB) + offload ~15–22 llama.cpp

Gemeten met llama.cpp (CUDA build) of Ollama op Windows 11 / Ubuntu 24.04, 4K–8K context, RTX 40-serie driver 560+. Snelheden zijn generation speed (niet prompt-processing). Variatie door systeemconfiguratie, driver en contextgrootte is normaal.