Best local LLM for coding in 2026: measured

Every few weeks a new "best local LLM for coding" list lands. They rank the right models — Qwen3-Coder-30B-A3B at the top of the open-weight tier, the smaller Qwen2.5-Coder and DeepSeek-Coder variants below it, the occasional Mistral Codestral mention. The lists are correct. They are also nearly useless on their own, because not one of them tells you the only thing that matters once the model has to fit on a card you own: what does stepping down a quant tier cost you in measured coding quality, and what does it buy you back in tok/s?

This is that table — for the coder we actually run, across three quant tiers, on the same hardware. The headline finding is the kind of thing that only a lab can show: the quality delta is smaller than the speed delta, by a lot, and that asymmetry is the whole argument for Q4_K_M as the default.

The one distinction roundups keep blurring

Leaderboard scores are reported at FP16 or BF16 — full precision, the model as the lab shipped it. That is not the model you will run. You will run a quantized version, because FP16 of a 30B model is 60GB and does not fit on a consumer card. The quant tier you pick changes both the quality score AND the tok/s, in opposite directions, and the magnitude of each change is model-specific.

This is why "model X scored Y on HumanEval" is a half-answer. The full answer is "model X at quant Z on hardware W scored Y on HumanEval at N tok/s." Anything less than that is a leaderboard number with no local-inference reality attached. Our methodology requires all four.

What we measured

The model is Qwen3-Coder-30B-A3B-Instruct. The hardware is the Arc B60 Pro (24GB, Battlemage), running llama.cpp build b3500 through Vulkan with -ngl 99 -c 8192 -t 8 -b 512 --no-mmap. The workload pack is our 100-prompt HumanEval suite (workload-pack-v1). bm-003 holds the raw record.

Quant	HumanEval pass@1	Generation tok/s	TTFT (ms)	VRAM used
Q4_K_M	0.81	38.6	740	18.1 GB
Q6_K	0.84	27.4	980	22.6 GB
Q8_0	0.86	19.8	1320	24.0 GB

Read the table both ways. Vertically: quality rises with quant tier, speed falls, VRAM rises. Horizontally: each row is a complete recommendation, not just a score.

Q4_K_M is the practical default

The bottom row of the leaderboard is the one most people will actually run. 0.81 HumanEval pass@1 is not a frontier-cloud score, but it is a perfectly usable coding model — comfortably above the threshold where generated code is "right more often than it's wrong." At 38.6 tok/s on the Arc B60, generation is faster than you can read. The model fits in 18.1 GB, leaving 6 GB of a 24GB card for context. That is a real, all-day-usable configuration.

The honest version: Q4_K_M is not the highest quality tier. It is the tier where the quality-per-VRAM and the quality-per-tok/s curves both flatten out, and the next step up costs more than it returns. This is the Q4 default thesis applied to a specific coder, with the receipts.

Q6_K is the sweet spot, if you can spare the VRAM

If your card has headroom past 22.6 GB — a 24GB card with short contexts, or any bigger card — Q6_K is the tier where the quality jump is still worth the speed cost. 0.84 HumanEval is within 2 points of Q8_0's 0.86, and you get there at 27.4 tok/s instead of 19.8 — 38% faster generation for a 2-point quality hit. VRAM is 22.6 GB, leaving ~1.4 GB of headroom on a 24GB card. Tight but workable for short-context coding work.

The honest rule on Q6_K: only step up from Q4_K_M if your card comfortably holds the model plus your working context. If you're squeezing, the Q4_K_M + more-context configuration beats Q6_K + squeezed-context every time, because the context window is what lets the model see your code.

Q8_0 only if your card is bigger than the model

0.86 HumanEval is the best quality we measured. It is also the configuration that saturates the 24GB card at 24.0 GB with no usable context room — you can run the model but you cannot feed it your codebase. At 19.8 tok/s it is also the slowest tier by a wide margin. Q8_0 of a 30B model only makes sense on a 32GB+ card (a single R9700, a Mac with 48GB+ unified memory, dual NVIDIA). On a 24GB card, Q8_0 is a benchmark number, not a working configuration.

The cross-GPU picture

The quant tier is half the decision. The other half is the card. bm-001 ran the same Qwen3-Coder-30B-A3B Q4_K_M on a single R9700 and got 43.8 tok/s — marginally faster than the Arc B60's 38.6, on a card that costs roughly twice as much. bm-009 ran the same model on a dual-RTX-5070 rig through CUDA and got 172 tok/s — 4.5× the Arc, with the same Q4_K_M quality.

The takeaway: the card matters as much as the quant. A faster card at Q4_K_M beats a slower card at Q6_K on both speed and quality-per-second. Read the cross-vendor GPU comparison for the full measured table, and the MoE explainer for why a "30B" model with 3B active parameters is cheaper to run than the parameter count suggests.

What we did NOT measure

Honesty matters more than coverage. Here is what this article is not:

• Not a sweep of all coding models. We have measured Qwen3-Coder-30B-A3B in depth. We have not measured Codestral, DeepSeek-Coder-V2, Qwen2.5-Coder, StarCoder2, or any 7B-tier coder. The recommendation below is for the model we ran, not "the best of all coders."
• HumanEval is one benchmark. It correlates with real coding ability but does not capture everything that matters — debugging, refactor, repo navigation, long-context code comprehension. The quality deltas above are HumanEval deltas, not "the model got X% better at your job" deltas.
• Workload packs are not cross-comparable. bm-003 uses our 100-prompt HumanEval suite. bm-009 uses llama-bench single-prompt. The tok/s numbers are real but the protocols differ; do not divide one by the other. See methodology.
• No 7B-tier local data. There are good 7B coders we can recommend by reputation but cannot claim measured numbers for. We flag those below.

The recommendation, by hardware tier

Your card	Model + quant	Measured	Why
12GB (Arc B580, RTX 4060 Ti, RX 7600)	Qwen3-Coder-30B-A3B Q4_K_M won't fit; use a Q4_K_M 7B coder (Qwen2.5-Coder-7B / DeepSeek-Coder-7B, not measured by us)	—	The 30B MoE has only 3B active but the full weights are 18GB. A 7B dense coder at Q4_K_M is ~4.5GB and fits with context to spare.
16GB (Arc B60 16GB variant, RX 7800 XT)	Qwen3-Coder-30B-A3B Q4_K_M	bm-003	Fits with room for short context; 38+ tok/s on Arc-class hardware.
24GB (Arc B60 Pro, RX 7900 XTX, RTX 3090/4090)	Qwen3-Coder-30B-A3B Q4_K_M or Q6_K	bm-003	Q4_K_M for context headroom, Q6_K for quality if you keep contexts short.
32GB+ (R9700, Mac Studio 48GB+)	Qwen3-Coder-30B-A3B Q6_K or Q8_0	bm-001, bm-003	Big enough that Q8_0's quality advantage is reachable without sacrificing context.
Dual NVIDIA (2× 12GB)	Qwen3-Coder-30B-A3B Q4_K_M, tensor split	bm-009	172 tok/s — the fastest configuration we measured for this model.

For the full step-by-step of running a coding model locally — runtime choice, Open WebUI, the privacy angle — the private coding agent tutorial is the deep dive.

The takeaway

The best local LLM for coding in 2026, on the hardware most people actually own, is Qwen3-Coder-30B-A3B at Q4_K_M. Not because Q4_K_M is the highest-quality tier — it isn't — but because the quality cost of stepping down from Q8_0 is 5 HumanEval points, and the speed cost of stepping up to Q8_0 is 2×. For an all-day coding workflow where generation speed and context headroom matter more than a 5-point benchmark delta, the lower quant wins. Step up only when your card has headroom to spare, and check the fit with Model Fit before you commit.

The full Q4-default thesis — why Q4_K_M is no longer the compromise tier it was in 2024 — is in quantization in 2026: no compromise. The exact VRAM math for your card and model is in Model Fit. The raw records behind every number above are in the benchmark library.

Last verified: July 2026. The coding-model carousel moves fast — re-validate against the latest Qwen-Coder and DeepSeek-Coder releases before committing hardware.