Beste lokale LLM voor code: keuzes per 8 tot 24 GB VRAM

De beste lokale LLM voor code is op dit moment Qwen3 Coder 30B A3B op een kaart van 24 GB, Qwen2.5 Coder 14B op Q4 bij 12–16 GB, en Qwen2.5 Coder 7B op Q4 bij 8 GB. Ze draaien allemaal volledig offline, autocompleten en refactoren echte code, en kosten niets per token. Heeft je GPU minder VRAM dan het model nodig heeft, ga dan eerst één quant omlaag voordat je een maatje kleiner model pakt. Deze gids koppelt modellen aan VRAM-klassen, vergelijkt de twee coderfamilies waar mensen echt over twisten, en eindigt met commando’s die werken, zodat je over ongeveer vijf minuten lokaal code genereert.

Welke lokale LLM gebruik je voor code op jouw GPU?

Kies eerst op VRAM, dan pas model — het model past alleen als de gewichten plus context in het geheugen passen. Dit is de shortlist die in 2026 in community-benchmarks en dagelijks gebruik steeds bovenaan uitkomt:

VRAM	Model	Quant	Gewichten op disk	Waarom dit de sterkste is in deze klasse
8 GB	Qwen2.5 Coder 7B Instruct	Q4_K_M	~4.7 GB	Beste verhouding tokens-per-seconde-tegen-kwaliteit voor autocomplete en kleine refactors
12 GB	Qwen2.5 Coder 14B Instruct	Q4_K_M	~9.0 GB	Bewerkingen over hele bestanden passen in de context; nog steeds 30+ tok/s op een kaart uit de 3060-klasse
16 GB	Qwen3 14B of gpt-oss-20b	Q4_K_M	~9–12 GB	Beter redeneren op vage specs; kaarten uit de 4090-klasse houden het snel
24 GB	Qwen3 Coder 30B A3B	Q4_K_M	~18.6 GB	MoE: per token zijn maar ~3B parameters actief, dus de snelheid blijft bruikbaar

Twee regels maken deze tabel in de praktijk werkbaar:

1. Houd 1–2 GB VRAM over voor de KV-cache. Een 14B-model op Q4 plus een context van 8K tokens past niet in een budget van 10 GB — context telt mee in het totaal.
2. Ga een quant omlaag voordat je een modelmaat omlaag gaat. Q5/Q4-quants kosten een paar procent kwaliteit; een 7B-model in plaats van een 14B kost veel meer dan dat.

Hoeveel VRAM heb je nodig voor een lokale coding-LLM?

De eerlijke vuistregel: nodig VRAM ≈ gequantiseerde gewichten + 0,125 GB per 1K tokens context bij 8-bit KV-cache. In gewone getallen:

• 8 GB draait 7B–8B-modellen op Q4 comfortabel. Reken op antwoorden van autocomplete-lengte, 4K–8K context.
• 12 GB is de sweet spot voor 14B op Q4 — genoeg ruimte voor het model plus een realistische coding-context van 8K–16K.
• 16 GB opent dense-modellen uit de 20B-klasse en Qwen3 14B met langere context.
• 24 GB draait de Qwen3 Coder 30B A3B MoE op Q4, het dichtste bij een cloudwaardig coding-model dat je zelf kunt hosten.

Alleen CPU? Het werkt — llama.cpp draait een 7B Q4 met plezier op een laptop-CPU op 5–10 tok/s — maar zie het als een geduldsoefing, niet als dagelijkse optie. Voor de toolkant van het installeren van een runtime behandelt de Ollama vs LM Studio-vergelijking welke lokale LLM-tool je onder je modellen legt.

Qwen3 Coder vs DeepSeek: welke is beter voor code?

Dit is de matchup waar de autocomplete-balken echt over vragen, en het antwoord splitst netjes:

• Qwen3 Coder (30B A3B) is gebouwd voor de edit-lus: het volgt de conventies van instructieformaten voor tool calling, produceert consistente diffs en — het beslissende — het MoE-ontwerp zorgt dat per token maar ~3B parameters actief zijn, dus één kaart van 24 GB haalt 40–60 tok/s. Voor IDE-gebruik is responsiviteit kwaliteit.
• De DeepSeek V3/R1-lijn redeneert op een hoger niveau: architectuurbeslissingen, lastige algoritmes, meerstaps-redeneren. Maar de vlaggenschip heeft 600B+ parameters; lokaal draai je hem alleen zwaar gequantiseerd op multi-GPU- of Mac-rigs met unified memory, en hij schrijft sneller proza over code dan code.

Lokale keuze: Qwen3 Coder als dagelijkse optie, DeepSeek alleen als je de hardware hebt om hem bijna op volle precisie te hosten. Bij 8–16 GB is de discussie overbodig — de Qwen2.5/3 Coder-modellen zijn het sterkste dat past.

Hoe draai je de beste lokale LLM voor code met Ollama?

Vijf commando’s, van niets naar een OpenAI-compatibele API waar je editor iets mee kan:

# 1. Install Ollama (Linux)
curl -fsSL https://ollama.com/install.sh | sh

# 2. Pull the model that fits your VRAM bracket (8 GB card shown)
ollama pull qwen2.5-coder:7b

# 3. Chat with it interactively
ollama run qwen2.5-coder:7b

# 4. Use it as an OpenAI-compatible API from any tool
curl http://localhost:11434/v1/chat/completions 
  -d '{
    "model": "qwen2.5-coder:7b",
    "messages": [{"role": "user", "content": "Refactor this fn to be async: add(a,b){return a+b}"}]
  }'

# 5. Point tools that expect OPENAI_BASE_URL at it
export OPENAI_BASE_URL=http://localhost:11434/v1

Geen API-key, geen rate limit, geen rekening per token. Op Linux registreert de installer een systemd-unit, dus als de server zich ooit misdraagt zegt journalctl je waarom — de journalctl-cheatsheet heeft de exacte filters voor service-debugging.

Is een lokale LLM goed genoeg voor echt codewerk?

Ja voor de edit-lus, nee voor de harde problemen — en precies die scheiding is hoe je hem gebruikt. Een lokaal model van 14B–30B doet refactors, boilerplate, test-scaffolding, regex en “leg deze legacy-functie uit” sneller dan de meeste cloud-API’s een roundtrip maken. Waar hij verliest tegen de grote gehoste modellen is lang meerbestanden-redeneren en obscure framework-trivia — een 30B-model weet nu eenmaal minder dan een frontier-model.

De workflow die werkt: laat een lokaal model draaien voor 90% van je toetsaanslagen en pak alleen voor de gore ontwerpvragen een gehost frontier-model. Je code verlaat bij routinewerk nooit de machine, wat telt bij klantcode, en de VRAM die je al hebt vervangt stilletjes een abonnement.