What is the best local LLM for coding on 16GB VRAM in June 2026?

Gemma 4 12B at Q4_K_M (~8 GB) is the best generalist, and JetBrains Mellum 2 12B (2.5B active, Apache 2.0) is the best code specialist. Both fit fully resident in 16GB with room for KV cache. Qwen3-Coder-30B-A3B is stronger at raw coding but needs Q3 quantization or CPU offload to fit.

Can a local model replace Claude Code on 16GB VRAM?

Not fully. The best 16GB-adjacent local model scores about 52% on SWE-bench Verified versus 80.9% for Claude Opus 4.5, a 28.9-point gap. A Cline or Aider harness plus Mellum 2 or Gemma 4 12B covers roughly 70-80% of routine tasks; route the hardest multi-file work to a hosted API.

Does Qwen3-Coder-30B-A3B fit on a 16GB GPU?

Not at Q4_K_M, where resident memory hits roughly 19 GB. You need Q3_K_S or lower, partial CPU offload, or a 32GB unified-memory Mac. On a strict 16GB card it runs, but with quality or speed compromises that erode its raw-coding advantage.

Is running a local coding LLM cheaper than the Claude API?

Only against expensive tiers. An active developer spending $300/month on Claude Sonnet 4.5 breaks even on a ~$2,140 local rig in months. Against Claude Code Pro at $20/month or DeepSeek V4 at roughly $18/month, the rig never wins on cost. Local is a privacy and offline play, not a cost optimization.

What is JetBrains Mellum 2 actually for?

Mellum 2 is a 12B-total, 2.5B-active Apache 2.0 MoE with 128K context, released June 1, 2026. JetBrains positions it as a focal or sub-agent model for routing, RAG, and agentic workflows, not as a primary autonomous agent driver. It pairs well with harnesses like Aider and Cline.

Best Local LLM for Coding on 16GB VRAM: June 2026 Rankings

The best pure coding model you can download today does not fit on a 16GB GPU, and the model that fits best is not a pure coder. That tension defines the entire search for the best local LLM for coding on 16GB VRAM in June 2026, and it's why most leaderboard screenshots circulating on r/LocalLLaMA answer the wrong question.

Two releases this month reset the rankings. Google shipped Gemma 4 12B on June 3, a dense Apache 2.0 model explicitly designed for 16GB machines. JetBrains open-sourced Mellum 2 on June 1, the only Apache 2.0 code-specialist MoE that runs fully resident in 16GB.

TL;DR

Gemma 4 12B (Q4 ~8 GB) is the default pick: fast, multimodal, Apache 2.0.
Mellum 2 12B-A2.5B is the code specialist, with 128K context and Apache 2.0 licensing.
Qwen3-Coder-30B-A3B is the strongest coder but needs Q3 quantization or CPU offload on 16GB.
The gap to hosted Claude Opus 4.5 on SWE-bench Verified is 28.9 points. Plan around it, don't pretend it away.

On 16GB of VRAM in June 2026, run Gemma 4 12B for general coding work and Mellum 2 for code-specialist and sub-agent roles. Both fit fully resident at Q4_K_M with context to spare; nothing stronger does.

Key takeaways

Tier 1 means "fits fully resident at Q4_K_M with 8K+ context." Only Gemma 4 12B and Mellum 2 qualify.
Mellum 2 is a focal/sub-agent model by JetBrains' own framing, not a Claude Code replacement.
The practical local long-context ceiling on 16GB is 32K to 64K tokens, not 200K.
The closest open source Claude Code replacement is a stack: Cline or Aider, plus Ollama, plus one of the Tier 1 models.
Local wins on privacy, offline use, and high-volume completion. It rarely wins on raw cost.

The June 2026 tier list

Two models earn Tier 1 by fitting fully resident in 16GB at Q4_K_M while staying competitive in their size class. Everything else trades quality, speed, or memory headroom to squeeze in. Rankings reflect expected real-world coding quality while resident in VRAM, not leaderboard position.

Tier	Model	Quant	Weights (approx.)	Context	License	Verdict
1A	Gemma 4 12B	Q4_K_M	~7.5-8 GB	16K-32K	Apache 2.0	Best generalist; default pick
1A	Mellum 2 12B-A2.5B	Q4_K_M	~7-8 GB	128K	Apache 2.0	Best code specialist
1B	Qwen3-Coder-30B-A3B	Q3_K_S / offload	~12-14 GB at Q3	256K	Apache 2.0	Strongest coder, tightest fit
2	Codestral 25	Q4_K_M	~10 GB	128K	Apache 2.0 research	Good completion, weak refactor
2	DeepSeek-Coder-V2-Lite	Q4_K_M	~9 GB	128K	DeepSeek open weights	Viable, smaller community
2	Llama 4 Scout	Q4_K_M	~10 GB	1M (extrapolated)	Llama 4 Community	Pick for extreme context
3	Gemma 4 26B-A4B / 31B	Q4_K_M	17.99 / 19.89 GB	256K	Apache 2.0	Needs 24GB+

Note the resident-memory trap: weight file size is not VRAM usage. Add 10-25% for KV cache and activations. That's how Qwen3-Coder-30B-A3B's 12.6 GB Q4_K_M file balloons to roughly 19 GB resident, per the Ollama library entry and community testing.

What is the best local LLM for coding on 16GB VRAM?

Gemma 4 12B is the best all-around local coding model for 16GB VRAM, with Mellum 2 the better choice for code-specialist and agent-routing work. Gemma 4 12B's Q4 quant runs about 8 GB, leaving comfortable KV-cache headroom, and early community verdicts are strongly positive for its size class.

Gemma 4 12B is the second wave of the Gemma 4 family. Wave one landed April 2, 2026 with E2B, E4B, 26B-A4B, and 31B. In Simon Willison's release-day testing, the 26B-A4B GGUF came in at 17.99 GB and the 31B at 19.89 GB. Both sail past a 16GB card.

Wave two fixed that. Per Google's developer guide, Gemma 4 12B uses an encoder-free multimodal architecture: a 35M-parameter vision embedder replaces 27 vision transformer layers, and raw 16 kHz audio is sliced into 40 ms frames and projected linearly into the backbone.

No separate encoders means less latency and less memory. It ships with a Multi-Token Prediction companion model for faster local inference, and Android Authority confirmed it's aimed at consumer laptops with at least 16GB.

The r/LocalLLaMA consensus in early June: "Q4 quant is like 8 GB RAM. Crazy fast and great quality for its size. No, it's not as good as a 27B or 31B." That's the honest summary.

Mellum 2 from JetBrains: read the label carefully

Mellum 2 is the only Apache 2.0 code-focused MoE that fits fully resident in 16GB, but JetBrains explicitly markets it as a focal and sub-agent model, not an autonomous agent driver. That framing matters more than any benchmark number attached to it.

The specs, from the JetBrains announcement and the technical report on arXiv: 12B total parameters with 2.5B active, 64 experts with 8 active per token, Grouped-Query Attention with 4 KV heads, and a 128K context window, a 16x jump over Mellum 1's 8K. It was trained on 10.6 trillion tokens with the Muon optimizer in FP8 hybrid precision.

Base, Instruct, and Thinking variants are all Apache 2.0, with GGUF weights on Hugging Face.

JetBrains pegs coding performance at roughly Qwen 3.5 9B-class, a vendor-stated figure with no independent SWE-bench number published yet. Community reports add a caveat: it trails Gemma 4 12B on non-coding tasks. Use it where its 2.5B active parameters shine, which is fast, frequent inference in RAG pipelines and agent sub-tasks.

How big is the gap to hosted Claude?

The best 16GB-adjacent local model trails Claude Opus 4.5 by 28.9 points on SWE-bench Verified. Gemma 4 26B-A4B, the strongest model that even flirts with 16GB, scores 52% on the independent Artificial Analysis snapshot versus 80.9% for Opus 4.5. DeepSeek V4 sits at a reported 81% for $0.30 per million input tokens, hosted.

SWE-bench Verified, June 2026 snapshot (%)

Context matters here. SWE-bench Verified tests multi-file repository bug-fixing in a Docker harness, the hardest gap to close. On HumanEval+-style single-function completion, the local-to-frontier gap is typically 15 to 25 points per the CodeSOTA leaderboard snapshots, and on LiveCodeBench, Gemma 4 26B-A4B's provider-reported 77.1% gets close.

Treat these deltas as ±5 points; harness versions and prompt templates move them.

One more reference point: Anthropic's Fable 5 and Mythos 5 announcement describes frontier-class capability, but no developer API pricing is public as of June 2026, so Opus 4.5 remains the priced hosted baseline.

Building an open source Claude Code replacement

The closest open source Claude Code replacement is a stack, not a product: Cline or Aider as the harness, Ollama as the runtime, and a Tier 1 model behind it. Both harnesses consume any OpenAI-compatible endpoint, and Cline's Ollama integration is documented first-party.

Aider has the strongest repository-map and auto-commit story for terminal users. Cline brings a plan-and-act loop with full MCP support inside VS Code. OpenCode, backed by Red Hat, is the model-neutral option if you live in OpenShift Dev Spaces. All three are Apache 2.0.

Two honest gaps remain. First, long-horizon planning: a 12B model loses the thread on tasks Claude Code decomposes across parallel sub-agents, so scope local tasks tightly. Second, context: KV cache costs roughly 0.5 GB per 8K tokens at FP16 on a typical 4-KV-head model, so the practical ceiling on 16GB is 32K to 64K with Q4 KV quantization, not 200K.

And a clarification the forums keep mangling: Holo3.1 from H Company is a computer-use vision-language model for GUI control (79.3% on AndroidWorld for the 35B-A3B variant), not a coding LLM. Pair it with Mellum 2 if you want computer use in your stack. Don't route your repo through it.

When does local actually beat the API?

Local wins on privacy, offline access, and reproducibility. It loses on cost against cheap hosted tiers, and it's not close. For an active developer pushing 50M input and 10M output tokens monthly, Claude Sonnet 4.5 runs $300/month while a ~$2,140 RTX 4080 rig amortizes to roughly $70/month all-in. That break-even arrives in about a month.

Flip the comparison and the rig never recovers its cost. GPT-5 mini handles the same volume for $32.50/month, DeepSeek V4 for around $18, and Claude Code Pro is a flat $20 subscription. A light user (5M input, 1M output) paying $3.25/month on GPT-5 mini is dominated by hosted economics by orders of magnitude.

So the defensible cases for local: proprietary code under contractual or regulatory constraints, air-gapped or offline environments, hundreds of small completion prompts daily where per-call overhead bites, and research that needs pinned weights. Hosted model behavior drifts; a local GGUF doesn't.

What this means for you

If you own a 16GB card today, pull both Tier 1 models through Ollama and split the work. Gemma 4 12B for general coding, explanation, and anything touching images or audio (its function calling is documented, though tool-call error rates on long sequences run higher than frontier models).

Mellum 2 Thinking for code-specialist passes and as the fast sub-agent in an Aider or Cline workflow.

If you're buying hardware specifically for this, pause. Spend $20/month on Claude Code Pro first and find out whether local privacy or offline access is actually your constraint. If raw capability is what you need, no 16GB setup closes a 28.9-point SWE-bench gap.

And if you can stretch to 24GB or a 32GB Mac, the calculus changes: Qwen3-Coder-30B-A3B at Q4 and Gemma 4 26B-A4B both come into play, and the quality jump is real. On strict 16GB, the June 2026 answer is settled.

Run the 12Bs, keep a hosted key for the hard 20%, and re-check this ranking monthly; the Gemma 4 cadence suggests a third wave is plausible.