Quick answer: The Qwen3-Coder version you can actually run locally is the 30B-A3B MoE: it fits a 24GB GPU at Q4_K_M (about 19GB), activates only ~3.3B parameters per token so it runs fast, and natively handles 256K context. The 480B flagship needs a server. For agentic, multi-file coding at home, it is the strongest small-footprint pick in 2026.
If you want one local model to drive Aider, Continue, or Cline in 2026, Qwen3-Coder is the first name to check. This review cuts through the hype: the headline 480B version is not for you, the 30B-A3B version very much is, and it fits a single 24GB GPU while running faster than the dense 32B coder most people are still using. Here is exactly what runs, how fast, how to wire it into your editor, and where it still loses to the competition.
What Qwen3-Coder is (and which one you can actually run)
Qwen3-Coder is Alibaba’s dedicated coding line built on Qwen3. As of mid-2026 it ships in two main sizes, both Mixture-of-Experts (MoE):
- Qwen3-Coder-480B-A35B, the flagship. 480B total parameters, roughly 35B active per token, and it benchmarks in the neighborhood of frontier hosted models on agentic coding. At Q4 it is around 290GB on disk. This needs a multi-GPU server or a 512GB unified-memory Mac. It is not a home-GPU model, and you should ignore anyone who implies otherwise.
- Qwen3-Coder-30B-A3B, the one this review is about. 30.5B total parameters, only ~3.3B active per token, native 256K context. At Q4_K_M it is about 19GB, which lands comfortably on a 24GB card.
If you want a dense ~32B coder instead of an MoE, that is still Qwen2.5-Coder-32B territory, the Qwen3-Coder line centers on these two MoE sizes rather than a dense 32B. More on that trade below.
The Qwen team has kept iterating since. Qwen3-Coder-Next (~80B total, only ~3B active, 256K context) pushes the same MoE-speed idea further for agent scaffolds, and the general-purpose Qwen3.6-27B dense model that arrived in mid-2026 has become a genuinely strong single-24GB-GPU coder in its own right. Both are worth watching. But for a straightforward, easy-to-pull 24GB coding driver, the 30B-A3B reviewed here is still the model to start with, and it’s the focus below.
The 30B-A3B trick: why a “30B” model runs fast
Here is the thing nobody tells you when they see “30B”: this model does not run like a 30B. It is Mixture-of-Experts, so while all 30.5B parameters live in VRAM, only about 3.3B of them fire for any given token. You pay the memory cost of a 30B model but pay the speed cost of a ~3B one.
In practice that means on a 24GB card holding the whole model, Qwen3-Coder-30B-A3B is often noticeably faster than a dense Qwen2.5-Coder-32B on the same hardware, commonly a couple of times the throughput, though you should verify on your own rig. For agentic coding, where the model makes dozens of tool calls per task, that latency difference is the entire experience. A fast model you can actually iterate with beats a slightly smarter one that stalls on every step.
How it performs on real coding work
Qwen3-Coder was tuned specifically for agentic coding, multi-step tasks where the model reads files, edits them, runs commands, and reacts to output. That is where it shines and where it justifies picking it over a general model like Qwen3 32B:
- Tool use and function calling are strong and reliable, which is what makes it behave well inside Aider and Cline rather than getting confused about edit formats.
- Long context is the standout feature: 256K tokens natively, extendable toward ~1M with YaRN. That means you can feed it a real repository slice, not just one file. (Just remember the memory cost, see below.)
- Everyday generation and refactoring are solid across mainstream languages: Python, TypeScript/JavaScript, Go, Rust, SQL.
On published benchmarks the 30B-A3B posts respectable agentic-coding numbers for its size, but treat all such scores as directional, benchmark contamination and version churn are real, so measure it on your tasks before you crown it. The honest summary as of 2026: it is the strongest small-footprint agentic coder you can run at home, not a Claude-tier replacement.
Which size and quant fits your GPU
Weights are only part of the story, long context inflates the KV cache, which is what actually pushes you into out-of-memory territory. If you hit that wall, our notes on increasing the context window will save you.
| Model | Type | Total / active | Context | VRAM (Q4_K_M) | Runs on | Best for |
|---|---|---|---|---|---|---|
| Qwen3-Coder 30B-A3B | MoE | 30.5B / ~3.3B | 256K | ~19GB | 24GB GPU | Fast agentic coding, long context, tool use |
| Qwen3-Coder 480B-A35B | MoE | 480B / ~35B | 256K | ~290GB | Server / 512GB Mac | Frontier agentic coding (not a home GPU) |
| Qwen2.5-Coder 32B | Dense | 32B / 32B | 128K | ~19-20GB | 24GB GPU | Rock-solid single-file completion |
Practical VRAM math for the 30B-A3B at Q4_K_M: ~19GB of weights on a 24GB card leaves roughly 4-5GB for the KV cache and overhead, which is enough for about 16K-32K of context. Push context toward the full 256K and you will spill into system RAM or OOM, that huge window is a capability, not a default you leave on. On a 16GB card the model does not fully fit; Ollama offloads layers to CPU/RAM (expect single-digit to low-tens tokens/sec), or you drop to a smaller quant and short context.
How to run Qwen3-Coder locally
The fastest path is Ollama. Install it first if you have not, then:
ollama pull qwen3-coder:30b # 30B-A3B MoE, ~19GB at Q4_K_M
ollama run qwen3-coder:30bqwen3-coder:30b is the same as the default qwen3-coder:latest. If you want higher fidelity and have the VRAM headroom, qwen3-coder:30b-a3b-q8_0 is roughly 32GB; the fp16 tag (~61GB) is for multi-GPU or big-RAM setups. To open the context window past Ollama’s conservative default, set it explicitly:
OLLAMA_CONTEXT_LENGTH=32768 ollama servePrefer a GUI? LM Studio carries GGUF builds of the 30B-A3B too, search for Qwen3-Coder-30B-A3B-Instruct, pick a Q4_K_M quant, and it exposes an OpenAI-compatible endpoint your editor can hit.
Wire it into your editor
A local coding model is only useful inside an agent. Three good pairings:
Aider (terminal, great for whole-repo edits), see the full Aider local setup:
export OLLAMA_API_BASE=http://127.0.0.1:11434
aider --model ollama_chat/qwen3-coder:30bContinue.dev (VS Code / JetBrains inline + chat), full walkthrough in our Continue.dev guide. The provider block is simply:
{
"models": [
{
"title": "Qwen3-Coder 30B",
"provider": "ollama",
"model": "qwen3-coder:30b"
}
]
}Cline (autonomous VS Code agent), set the API provider to Ollama, point it at http://127.0.0.1:11434, and select qwen3-coder:30b. Its strong tool-calling is what makes Cline’s plan-then-edit loop actually work with a local model.
Qwen3-Coder vs Qwen2.5-Coder-32B: which to pick
This is the real decision for most readers, because both fit a 24GB GPU at around 19GB.
- Pick Qwen3-Coder 30B-A3B if you do agentic, multi-file, tool-driven work, want lower latency, or need context past 128K. The MoE speed and 256K window are the reasons it exists.
- Pick Qwen2.5-Coder-32B if you mostly want single-file completion and refactors and value the steady, predictable feel of a dense model. It remains one of the most consistent local coders and, being dense, sometimes edges out the MoE on tightly focused reasoning.
Weaknesses to be honest about: the 30B-A3B is not the 480B, so it will lose on genuinely hard, sprawling tasks; long context eats memory fast; and like every local model it hallucinates APIs, so review its edits. It is the best home-runnable coder in 2026, not a magic senior engineer.
Your code, your machine
The whole point of running Qwen3-Coder locally is that your proprietary code, your prompts, and your repo never leave your GPU, no cloud, no logging, no per-token bill. If the other thing on your list is an AI companion, Ember is the zero-setup counterpart: an uncensored 18+ companion with her own tuned brain, running locally in about 7GB, so a 24GB card can keep coding duty alongside her.
Still deciding what silicon to buy for a local coding rig? Start with our best local coding model by VRAM guide and match the model to the card before you spend a cent.