De Beste Lokale LLM voor Coderen in Augustus 2026, op VRAM: Qwen3-Coder 30B, gpt-oss-20b, Qwen 2.5 Coder 7B

De beste lokale LLM voor coderen in augustus 2026 wordt in de eerste plaats bepaald door je VRAM. Als je een 24GB-kaart hebt — een RTX 3090 of 4090 — draai dan Qwen3-Coder-30B-A3B-Instruct: 30B totale parameters met slechts 3,3B actieve parameters per token, een contextvenster van 262.144 tokens, en de beste allround lokale codeercijfers die we kunnen verifiëren. Op 16GB is het gpt-oss-20b, O​penAI's Apache-2.0 Mixture-of-Experts-model dat volledig op de GPU past bij ~14GB en ongeveer 140 tokens per seconde haalt. Op 8GB is het Qwen2.5-Coder-7B, het betrouwbare werkpaard op ~4,7GB. De rest van deze pagina is de redenering, de gemeten cijfers en de specifieke situaties waarin elk van deze keuzes verkeerd is.

Wat pagina één goed doet — en wat het overslaat

De ranglijst voor "beste lokale llm voor coderen" is op dit moment een mix van één werkelijk nuttig artikel en veel domeinsterkte. Tembo's gids (5 juni 2026) heeft de juiste opzet — het verdeelt in categorieën van 8GB / 12–16GB / 24GB en komt uit op de Qwen Coder-familie — maar het publiceert geen benchmarkscores voor de lokale modellen, geen tokens-per-seconde-cijfers, geen contextvenstergroottes en geen Apple Silicon-keuzes per RAM. Een GitHub eval-harness (gauravvij/local-llm-coding-eval) heeft echte cijfers, maar geen oordeel en draaide alleen op CPU. De rest zijn opinieartikelen van één auteur (XDA, Yahoo Tech) en dunne lijstjes (apidog, Security Boulevard, SitePoint) die rangschikken op basis van domeinsterkte, niet op bruikbaarheid.

Wat ze allemaal overslaan, in volgorde van hoeveel het je kost:

• De agentische kloof. Codegeneratie is niet dezelfde vaardigheid als het aansturen van een agent bij een wijziging over meerdere bestanden. Pagina één noemt het nauwelijks; het is het verschil tussen een model dat je houdt en een model dat je deïnstalleert.

• Contextvensters. Agentisch coderen verbruikt tokens bij het laden van bestanden en testuitvoer. Een bewering als "30B past in 24GB" is betekenisloos totdat je vraagt bij welke contextgrootte dat past.

• Kwantiseringswiskunde. Niemand legt uit dat 4-bit ongeveer het aantal parameters in gigabytes nodig heeft, of dat Q3 VRAM bespaart ten koste van subtiele syntaxfouten.

• Gemeten snelheid.Weinig stukken vermelden tokens/sec voor de modellen die ze aanbevelen, en de stukken die dat wel doen lopen sterk uiteen, omdat context en kwantisering alles veranderen.

• Wanneer lokaal de verkeerde keuze is. Een veldtest uit 2026 op een Flutter-app van 15.000 regels (EPAM) laat nog steeds zien dat cloud-frontiermodellen de moeilijkste meerstapsrefactors winnen. Geen van de listicles vertelt je wanneer je moet stoppen.

De VRAM-berekening die de meeste lijstjes overslaan

De vuistregel die elk ander getal in dit artikel leesbaar maakt: bij 4-bit kwantisering heeft een model ruwweg evenveel gigabytes nodig als het aantal parameters — 7B ≈ 5GB, 30B ≈ 18GB+, vóór KV-cache-overhead. Q4 is de sweet spot voor coderen; Q3 en lager besparen VRAM maar introduceren meetbaar subtiele syntaxfouten. En de KV-cache groeit met je contextvenster, daarom is "een 30B past in 24GB" alleen waar bij een context die je daadwerkelijk moet specificeren.

Mixture-of-Experts verandert de wiskunde op een manier die ertoe doet voor de twee grote keuzes hieronder. Totale parameters bepalen de voetafdruk; actieve parameters bepalen de snelheid. Daarom voelen Qwen3-Coder-30B-A3B (30B totaal, 3.3B actief) en gpt-oss-20b (20.9B totaal, 3.61B actief) beide veel sneller aan dan hun gewicht op schijf doet vermoeden, en is DeepSeek V4 Flash — 284B totaal, 13B actief — slecht geschikt voor lokaal gebruik, ook al is de API goedkoop.

24GB VRAM: Qwen3-Coder 30B

Qwen3-Coder-30B-A3B-Instruct is op dit moment de sterkste allround lokale coder waar we naar kunnen verwijzen. Uitgebracht in juli 2025 door Alibaba's Qwen-team onder Apache 2.0, is het een Mixture-of-Experts-model met 30B totale parameters en 3.3B actieve parameters per token, een contextvenster van 262.144 tokens en een 4-bit voetafdruk van ongeveer 17–20GB — wat echte ruimte overlaat op een 24GB-kaart voor de KV-cache die een lange codeersessie nodig heeft.

Op de onafhankelijke lokale testopstelling die we het meest vertrouwen (gauravvij/local-llm-coding-eval, vier modellen lokaal gedraaid via Ollama op CPU), behaalde qwen3-coder:30b 80% codegeneratie, 77% toolselectie en 80% agent-nauwkeurigheid — het meest gebalanceerde resultaat van de vier, en het enige model dat sterk was in alle drie de taken tegelijk. Trackers van derden stellen de SWE-bench Verified rond 50,3, Aider Polyglot op 66,2 en LiveCodeBench v6 op 58,9; behandel die als verzamelde cijfers, niet als officiële cijfers van Alibaba, wat alles is wat Qwen voor dit model heeft gepubliceerd.

De gemeten snelheid varieert sterk met de hardware. De meest bruikbare datapunten: een community-TurboQuant-setup draait het op een 8GB RTX 3060 Ti met ~29 tokens/sec generatie bij een volledige 262K-context, en de oMLX-benchmark mat de 4-bit MLX-build op een M4 Pro (48GB) op 73,6 tokens/sec bij 1K-context, dalend naar 13,5 tokens/sec bij 64K. Op een 24GB-kaart in een normale Ollama-setup moet je rekenen op tientallen tokens per seconde, niet honderden — de prijs die je betaalt voor het thuis draaien van een bijna-frontier codeermodel.

De eerlijke kanttekening: het is niet de snelste lokale coder, en er bestaat een nieuwere Qwen3-Coder-Next die gericht is op hosted- en CLI-gebruik in plaats van gekwantiseerde lokale installaties. Maar voor agentische, repo-schaal werk op één kaart is Qwen3-Coder-30B vandaag de keuze.

16GB VRAM: gpt-oss-20b

Op een 16GB-kaart is het antwoord gpt-oss-20b — en het is niet eens in de buurt. Uitgebracht op 5 augustus 2025 door OpenAI onder Apache 2.0, is het een Mixture-of-Experts-model met 20,9B totale parameters en 3,61B actieve parameters per token, een contextvenster van 131.072 tokens, en de native MXFP4-kwantificatie heeft een omvang van ongeveer 14GB. Dat is het beslissende feit: het draait 100% op de GPU op een 16GB-kaart, zonder dat er iets naar het systeem-RAM overloopt.

Waarom residentie op de GPU meer telt dan welke benchmark dan ook: een model dat in het VRAM past is 3–11x sneller dan een model dat offloadt. Een onafhankelijke benchmark registreerde 139,93 tokens/sec voor gpt-oss-20b op een RTX 4080 — ruwweg 2,8x een dicht alternatief met dezelfde voetafdruk — en de score van een tester uit 2026 gaf het een 'intelligentie-index' van 52,1, en noemde het ongeëvenaard in de 16GB-klasse voor professioneel coderen en debuggen. Het past net, dus draai het alleen en houd de context bescheiden; de kwaliteit neemt af aan de bovenkant van het venster.

Het agentische alternatief op 16GB is Devstral 24B (devstral-small-2:24b), dat de enige gepubliceerde SWE-bench Verified-score heeft onder de lokale codeermodellen van de 16GB-klasse — 46,8% — maar het is traag en heeft vaak CPU-offload nodig bij ~18 tokens/sec. Als je werk bestaat uit multi-file agentische bewerkingen en je de snelheid kunt accepteren, verdient Devstral zijn plek; als je snelheid plus schone code wilt, is gpt-oss-20b de betere standaard. Dichte 14B-modellen — Qwen3-Coder 14B of Qwen2.5-Coder 14B op Q5 — zijn de comfortabele, goedkope alternatieven.

8GB VRAM: Qwen 2.5 Coder 7B

Op 8GB is het eerlijke antwoord Qwen2.5-Coder-7B: 7B parameters op ~4,7GB in Q4_K_M, een native context van 32.768 tokens die uitbreidbaar is tot ~128K, en de sterkste code-completion benchmarkscores in de 7B-klasse. Het is een ouder model — uitgebracht in november 2024 — en dat is prima, want niets nieuwer in het 8GB-segment heeft het van de troon gestoten. Communitytests schatten het op ongeveer 50 tokens/sec op een RTX 4060 of 3070; een onafhankelijke RTX 4060-test in maart 2026 mat 28–35 tokens/sec, een spreiding die vrijwel volledig wordt bepaald door contextinstellingen.

Drie dingen doen ertoe bij 8GB die elders niet gelden. Ten eerste: begrens de context op 4–8K — het is de KV-cache, niet de gewichten, die een 8GB-kaart OOM laat gaan. Eén benchmark zag de snelheid stijgen van ~3,6 naar ~37 tokens/sec puur door het begrenzen van de context. Ten tweede: controleer met ollama ps dat het model 100% op de GPU draait; als er ook maar iets op de CPU terechtkomt, stort de snelheid in. Ten derde: Q4_K_M, niet Q3 — de syntaxfouten van Q3 kosten je meer dan de VRAM-besparing oplevert.

De opmerkelijke ontwikkeling van 2026 is dat Qwen3-Coder-30B-A3B-Instruct nu op 8GB kan worden gepropt via TurboQuant KV-cachecompressie — een community-opstelling mat ~7,5GB en ~29 tokens/sec op een RTX 3060 Ti bij volledige 256K-context. Het werkt, maar het is zo omslachtig dat we het niet als standaard aanbevelen. Als je een nieuwere kant-en-klare optie wilt, is Qwen3 8B (~5,2GB, hybride denkmodus) een kleine stap vooruit ten opzichte van Qwen2.5-Coder-7B op algemeen redeneren, terwijl het op pure code iets achterblijft.

Hoe zit het met Apple Silicon?

Unified memory verandert de rekensom in één richting: de capaciteit neemt toe, de generatiesnelheid neemt af. Een 48GB M4 Pro kan modellen draaien die een 16GB Windows-videokaart niet kan, maar het genereert tokens veel langzamer bij lange context. De cijfers die we hebben: de 4-bit MLX-build van Qwen3-Coder-30B-A3B-Instruct gebruikte 16,6GB bij 1K-context en 25,5GB bij 64K op een M4 Pro, waarbij de generatiesnelheid daalde van 73,6 tokens/sec naar 13,5 naarmate de context groeide (oMLX-benchmark). gpt-oss-20b past comfortabel in 16GB unified memory en is een prima Mac-keuze. Als je multimodaal wilt op Apple Silicon, Gemma 4 12B draait in ongeveer 16GB unified memory met een 256K-context — de sterkste lokale optie als je codeerwerk zich naast beeldzware documenten afspeelt.

De onafhankelijke cijfers: codegen is niet de vaardigheid die ertoe doet

De duidelijkste data die we vonden is een enkele lokale benchmark die het waard is om in zijn geheel te citeren. gauravvij/local-llm-coding-eval draaide vier modellen lokaal via Ollama, op CPU, geen cloud — codegeneratie, functieaanroepen, en een meerstaps agent-taak — met resultaten die ingaan tegen het instinct dat 'een hoger codegen-getal wint':

• Qwen3.6 27B (qwen3.6:27b, dense, ~17GB): 80,0% codegen, 84,6% tools, 100% agent — de beste allrounder.

• Qwen3.6 35B A3B (qwen3.6:35b-a3b, MoE, ~18GB): 70,0% codegen, 84,6% tools, 100% agent.

• Qwen3-Coder-30B-A3B-Instruct (qwen3-coder:30b, MoE, ~17GB): 80.0% codegen, 76.9% tools, 80% agent — meest gebalanceerd.

• DeepSeek-Coder-V2 33B (deepseek-coder:33b, dense, ~18GB): 90.0% codegen — de beste van de vier — maar 10% agent, allerlaatste op meerstapswerk.

Die laatste regel is de hele les. Een model dat aan kop staat in pure codegeneratie maar instort bij agenttaken, is het model dat je zult deïnstalleren na de eerste "lees dit bestand, wijzig deze functie, voer de test uit"-lus. Beoordeel een lokale coder op de agentische kolom, niet op de codegen-kolom.

Wanneer lokaal draaien de verkeerde keuze is

Local-first is de juiste standaard voor privacy, offline werk, nul marginale tokenkosten en automatische aanvulling waar latentie belangrijker is dan de maximale kwaliteit. Het is de verkeerde keuze in specifieke, herkenbare situaties — en dit is het gedeelte dat pagina één overslaat:

• Het zwaarste agentische werk gaat je nog steeds te boven.EPAM's veldtest van 2026 op een Flutter-app van 15.000 regels toonde aan dat cloud-frontiermodellen (GPT-5.3-codex) lokale modellen nog steeds overtroffen bij de meest complexe meerstapsrefactoring. Als je werkdag uit acht uur refactoren van legacycode bestaat, is lokaal nog niet klaar.

• Je contextbehoeften overstijgen je kaart. Een codeagent die een hele repo laadt, schiet ver voorbij de KV-cache die een 16GB-kaart kan bevatten. De 256K-context van Qwen3-Coder-30B is de reden dat hij de 24GB-categorie wint — kleinere kaarten verliezen dit spel vroegtijdig.

• Je kunt niet op hardware oppassen. De hardware is echt geld: een 24GB-kaart valt in de klasse van $700–1.600, plus elektriciteit en onderhoud. Bij lage volumes is een API aanroepen goedkoper dan het stroomverbruik.

• DeepSeek V4 Flash is het bewijs. Met 284B totale parameters zijn de 4-bit gewichten van DeepSeek V4 Flash alleen al ongeveer 140GB — geen consumentenkaart-model, punt uit. Het 13B-actieve ontwerp is precies de reden waarom de API snel en goedkoop is tegen $0.15 / $0.29 per 1M tokens (MIT, 1M context). Voor dat model is 'lokaal draaien' de verkeerde vraag; de API is waar het om draait.

• Teams hebben consistentie nodig. Als vier engineers elk een andere kwantisatie van een ander model draaien, wordt "werkt op mijn machine" een buildrisico. Gedeelde API-eindpunten geven je één deterministisch doelwit.

Als u het antwoord van de API-kant op dezezelfde vraag wilt — welk cloud-codemodel de standaard is wanneer lokaal niet de juiste afweging is — hebben we dat apart behandeld in onze best-LLM-for-coding-gids, en ons artikel over AI-coding-agents behandelt tools zoals Cline en OpenCode die met deze lokale modellen werken.

Hoe test je voordat je de kaart koopt

De goedkoopste manier om te beslissen is om je eigen prompts te draaien voordat je je vastlegt op hardware. Met Ollama of LM Studio draai je elk van de drie keuzes binnen enkele minuten, en de test die ertoe doet, zijn de echte bestanden in je repo, niet een benchmark. Een router verdient zijn plaats bij de aangrenzende beslissing: wanneer je een lokale kandidaat vergelijkt met gehoste frontier-modellen, kun je met één endpoint dezelfde prompt door beide halen zonder met sleutels te hoeven jongleren. Op OrcaRouter wordt DeepSeek V4 Flash aangeboden tegen de lijstprijs van de provider, ongewijzigd doorgegeven — $0.15 / $0.29 per 1M tokens, 0% opslag — met automatische failover, wat het een goedkope en eerlijke maatstaf maakt voor 'is mijn lokale model echt beter dan de $0.15 API?'

Eén eerlijk voorbehoud: OrcaRouter host geen Qwen3-Coder-30B-A3B-Instruct of gpt-oss-20b. Als je doel strikt offline is, is een router voor jou irrelevant — self-host en je bent klaar. Als je doel is om hetzelfde open-weight model tegen de frontier te A/B-testen voordat je aan een kaart uitgeeft, is de taak van de router de vergelijking, niet het hosten.

De bottom line

Je VRAM bepaalt eerst, de modelkwaliteit pas daarna. Op 24GB draai je Qwen3-Coder-30B-A3B-Instruct — de sterkste allround lokale coder, met de 256K context die agentisch werk nodig heeft. Op 16GB draai je gpt-oss-20b — het zeldzame model dat zowel snel als volledig op de GPU draait. Op 8GB draai je Qwen2.5-Coder-7B en houd je je context bescheiden. Beoordeel ze allemaal op de agentische kolom, niet op de codegen-kolom, en accepteer dat de moeilijkste multi-file refactoring nog steeds aan de cloud is. De bovenstaande cijfers zijn actueel per 10 augustus 2026 — controleer opnieuw de line-up en de vermelde prijzen voordat je uitgeeft, want deze ruimte verandert wekelijks.