If you have a 16GB GPU and want one model to run locally in November 2026, use gpt-oss-20b. It's a 20.9B-parameter mixture-of-experts model that ships in native MXFP4 at about 12GB, it's Apache-2.0, and that modest footprint is the whole reason to pick it: it leaves several gigabytes free for context, where a model that fills your card with weights alone will crash the moment a session runs long. If you only write code, Qwen2.5-Coder-14B-Instruct (dense, ~9GB, Apache-2.0) is the safe specialist. And the model half the internet will tell you to run — a 30B-A3B MoE — does not actually fit. Here's why, and what to run instead.

This is the 16GB companion to our open-weight coding ranking (which assumes a 24GB card) and our guide to the cheapest 16GB GPUs for local AI. If you're choosing hardware and model together, read those alongside this.

The VRAM math the roundups skip#

Most "best LLM for 16GB" lists quote a model's Q4 file size, check that it's under 16, and call it a fit. That's wrong, and it's how you end up out-of-memory three turns into a real task.

Three things share your card, not one:

  1. Usable VRAM is not 16GB. You get about 15–15.5GB in practice — less on Windows with a desktop compositor running, a bit more on a headless Linux box.
  2. The weights are only the first tenant. Whatever's left has to hold the KV cache, which grows with context length. For a 14B-class model, 16k tokens of context can add ~3GB on top of the weights.
  3. Compute buffers take a sliver more.

"Only 3B active" tells you the speed. The 30B total tells you the VRAM. Confuse the two and you'll buy a model that benchmarks beautifully and won't load.

So the honest tiers for a 16GB card are:

The picks that actually fit#

gpt-oss-20b — best all-rounder. OpenAI's open MoE is 20.9B total / 3.6B active, Apache-2.0, and ships in native MXFP4 at ~12GB — so it loads with room to think. It's also genuinely capable for its size: Codeforces Elo around 2230 and AIME 2025 at 91.7 without tools, per OpenAI's card. If you run one model on 16GB, run this.

Qwen2.5-Coder-14B-Instruct — safe pure coder. Dense 14.7B, Apache-2.0, ~9GB at Q4_K_M. No MoE surprises, a dedicated code model, and enough spare VRAM to hold a large repo's worth of context. The dependable choice when the job is only code.

Qwen3-14B and Phi-4 — general-purpose at the same footprint. Qwen3-14B (dense 14.8B, Apache-2.0, ~9GB) is the reliable general chat/reasoning pick; Microsoft's Phi-4 (14.7B, MIT — the cleanest license here) punches above its weight on math and reasoning. Either leaves plenty of room for context.

Gemma 3 12B — smallest comfortable, and multimodal. At ~7.3GB it's the roomiest fit and it handles images. The catch is the license: Google ships it under the custom Gemma Terms of Use, not an OSI-approved one, with redistribution restrictions. Fine for running locally; read the terms before you ship a fine-tune.

Devstral Small 2507 — the strongest coder that fits, barely. Mistral's 24B agentic coder (Apache-2.0, 128k context) posts the best verifiable coding number of anything on this list — SWE-bench Verified 53.6% on the OpenHands scaffold. But at ~14.6GB (Q4_K_M) it fits only with context discipline; give it a long session and it will OOM. Reach for it when you want maximum coding quality and can keep the context tight.

The trap: the 30B-A3B models#

The single most-recommended "16GB" model is a mixture-of-experts like Qwen3-Coder-30B-A3B or the general Qwen3-30B-A3B. The pitch is seductive: 30B of knowledge, only ~3B active per token, so it's fast. But all 30B parameters live in VRAM, and at Q4_K_M that's ~17–19GB — over budget before any context. Your only outs are a 3-bit quant (which degrades exactly the hard tasks you wanted the big model for) or CPU offload (which kills throughput). These are superb models on a 24GB card. On 16GB they're a mismatch, no matter how many roundups list them.

The rule stands: on a 16GB card, size your model by weights plus context, favor a ~9–12GB footprint, and check the "Files and versions" tab of the exact GGUF repo you pull — quant sizes drift ±0.3GB between repackagers. Want to go smaller or run several models? Our guide to local LLMs for coding on your own machine covers the tooling. But if you just want the one answer: gpt-oss-20b, and leave room to breathe.