Looking for Qwen3-Coder-Next? It is a separate 80B model (3B active, 52GB in Ollama) with its own benchmarks and setup: Qwen3-Coder-Next guide. This page covers the original Qwen3-Coder models, the 30B-A3B and the 480B-A35B.
Qwen3-Coder 30B and 480B: Run Alibaba's Coding Models Locally
Qwen3-Coder comes in two sizes. The 30B-A3B (30.5B total, 3.3B active) is 19GB in Ollama and is the default qwen3-coder tag: it runs on one 24GB GPU. The 480B-A35B flagship is 290GB at Q4 and needs server hardware. Both have a 256K context, Apache 2.0 licences and tool-calling for agentic coding. Below: the real Ollama tags, how much memory each build needs, and the SWE-bench scores Qwen has published.
Overview: Two Sizes, One Model Family
Alibaba's Qwen team released the 480B-A35B flagship on July 22, 2025, describing it as comparable to Claude Sonnet 4 on agentic coding, agentic browser-use and tool-use. Nine days later, on July 31, 2025, it published the 30B-A3B, a streamlined version with the same 256K context and function-call format that fits on a single consumer GPU. Ollama made the 30B the default qwen3-coder tag.
Qwen says the family was trained on 7.5 trillion tokens with a 70% code ratio. Both models are non-thinking only (no <think> blocks) and are built for agentic coding workflows where the model navigates a repository, writes code, runs tests and iterates. Qwen names Qwen Code and Cline as supported agent platforms.
Qwen3-Coder 30B-A3B
- Parameters: 30.5B total, 3.3B active per token
- Experts: 128 total, 8 active per token
- Layers: 48, GQA (32 Q heads, 4 KV heads)
- Context: 262K native, 1M with YaRN
- License: Apache 2.0
- Ollama:
qwen3-coder:30b, 19GB - Best for: Local development on one 24GB GPU or a 32GB Mac
Qwen3-Coder 480B-A35B
- Parameters: 480B total, 35B active per token
- Experts: 160 total, 8 active per token
- Layers: 62, GQA (96 Q heads, 8 KV heads)
- Context: 262K native, 1M with YaRN
- License: Apache 2.0
- Ollama:
qwen3-coder:480b, 290GB - Best for: Self-hosted team servers, maximum quality
Architecture Deep Dive
480B Flagship: Classic MoE at Scale
The 480B model is a Mixture-of-Experts transformer with 160 experts across 62 layers. Each token is routed to 8 experts, so 35B of the 480B parameters do the work for any one token. It uses grouped-query attention (96 query heads sharing 8 key/value heads), which keeps the KV cache small for a model this size, and supports 262,144 tokens natively, extendable to 1 million with YaRN.
30B-A3B: The Same Design, Scaled Down
The 30B-A3B keeps the recipe: 128 experts with 8 active across 48 layers, so only 3.3B parameters run per token. That is why it generates much faster than a dense 30B model on the same GPU, although all 19GB of the Q4 weights still have to sit in memory. Its 4 KV heads of 128 dimensions mean the KV cache costs about 96KB per token at FP16 (48 layers × 4 heads × 128 × 2 for K and V × 2 bytes).
Qwen3-Coder-Next, the 2026 follow-up, changed the architecture to a hybrid of Gated DeltaNet and gated attention with 512 experts; see the Qwen3-Coder-Next page for its details.
| Specification | 30B-A3B | 480B-A35B |
|---|---|---|
| Total Parameters | 30.5B | 480B |
| Active per Token | 3.3B | 35B |
| Expert Count | 128 (8 active) | 160 (8 active) |
| Layers | 48 | 62 |
| Attention heads (Q / KV) | 32 / 4 | 96 / 8 |
| Context Length | 262K (1M with YaRN) | 262K (1M with YaRN) |
| Training Tokens | 7.5T (70% code), family figure | 7.5T (70% code) |
| Architecture | MoE Transformer | MoE Transformer |
| License | Apache 2.0 | Apache 2.0 |
| Release Date | July 31, 2025 | July 22, 2025 |
Benchmarks
Qwen published the 480B's headline SWE-bench Verified score, 69.6% with the OpenHands scaffold at 500 turns, in the chart of its July 2025 announcement. The most detailed like-for-like numbers come later, from the Qwen3-Coder-Next Technical Report (arXiv 2603.00729), which also lists the 480B on non-agentic coding tests. Qwen published the 30B-A3B's own scores only as a chart image on its model card, but the official swebench.com board lists Qwen3-Coder 30B at 51.6% on SWE-bench Verified, run inside the OpenHands agent (read October 15, 2026).
SWE-bench Verified with OpenHands
480B: Qwen3-Coder announcement chart (500 turns). Other rows: Qwen3-Coder-Next technical report, Table 3. The two runs are from different reports, so treat a gap of a point or two as noise.
480B Non-Agentic Coding Profile
Qwen3-Coder-480B-A35B in the Qwen3-Coder-Next technical report, Table 6: EvalPlus 86.66, MultiPL-E 88.00, CRUXEval 92.13, LiveCodeBench v6 44.93, OJBench 14.98, Codeforces rating 1800.
| Benchmark (scaffold) | 480B-A35B | Coder-Next | DeepSeek-V3.2 | GLM-4.7 |
|---|---|---|---|---|
| SWE-bench Verified (OpenHands) | 69.6%* | 71.3% | 72.6% | 70.6% |
| SWE-bench Verified (SWE-Agent) | — | 70.6% | 70.2% | 74.2% |
| SWE-bench Multilingual (SWE-Agent) | — | 62.8% | 62.3% | 63.7% |
| SWE-bench Pro (SWE-Agent) | — | 42.7% | 46.0% | 45.1% |
| Terminal-Bench 2.0 (Terminus-2 JSON) | — | 36.2% | 39.3% | 37.1% |
| LiveCodeBench v6 | 44.93 | 58.93 | — | — |
| EvalPlus | 86.66 | 86.56 | — | — |
Note: — means the source does not publish that figure. *The 480B's 69.6% comes from Qwen's July 2025 announcement; every other number is from the Qwen3-Coder-Next technical report (Tables 3-6), read November 2, 2026. All are vendor-reported, and scores are only comparable within the same scaffold.
Quick Start with Ollama
30B-A3B (Recommended for Local Use)
Install Ollama, then pull the 30B. The plain qwen3-coder tag points at the same 19GB Q4_K_M build.
Other 30B builds: qwen3-coder:30b-a3b-q8_0 (32GB) and qwen3-coder:30b-a3b-fp16 (61GB). The 80B successor is qwen3-coder-next (52GB); see the Qwen3-Coder-Next guide.
480B-A35B Flagship (Server)
The Q4_K_M build is 290GB, so it needs roughly 300GB+ of GPU or unified memory before any context.
API Access (OpenAI-Compatible)
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama"
)
response = client.chat.completions.create(
model="qwen3-coder:30b",
messages=[
{"role": "system", "content": "You are an expert software engineer."},
{"role": "user", "content": "Write a Redis cache decorator in Python with TTL support."}
],
temperature=0.3,
max_tokens=4096
)
print(response.choices[0].message.content)Hardware Requirements
Both models are Mixture-of-Experts: only a small part runs per token, which keeps generation fast, but every expert has to be loaded, so memory is set by the total size. The sizes below are the Ollama downloads; add the KV cache for your context on top. See our quantization guide for what Q4_K_M and Q8_0 mean. We give no tokens-per-second figures: a memory-bandwidth ceiling does not describe MoE generation speed well.
Ollama Download Size by Quantization (GB)
30B-A3B (Consumer Hardware)
480B-A35B (Server)
Quantization & Memory Reference
| Variant | Quantization (Ollama tag) | Weights | Hardware Example |
|---|---|---|---|
| 30B-A3B | Q4_K_M (qwen3-coder:30b) | 19 GB | RTX 3090/4090 24GB with a 32K context; 32GB Mac |
| 30B-A3B | Q8_0 (qwen3-coder:30b-a3b-q8_0) | 32 GB | 48GB GPU (RTX 6000 Ada, 2× 24GB), 48GB+ Mac |
| 30B-A3B | FP16 (qwen3-coder:30b-a3b-fp16) | 61 GB | 80GB GPU (H100/A100), 96GB Mac |
| 480B-A35B | Q4_K_M (qwen3-coder:480b) | 290 GB | 4× H100 80GB (320GB, little room for context), 512GB Mac Studio |
| 480B-A35B | Q8_0 (qwen3-coder:480b-a35b-q8_0) | 510 GB | 8× H100 80GB |
| 480B-A35B | FP16 (qwen3-coder:480b-a35b-fp16) | 960 GB | 8× H200 141GB |
Sizes from the Ollama library, read November 2, 2026. KV cache for the 30B is about 96KB per token at FP16 (roughly 3GB at 32K context, 12-13GB at 128K).
Model Comparison
How Qwen3-Coder compares with other open-weight coding models you can pull from Ollama, by size and the hardware each needs. For benchmark scores, see the table above and our best Ollama model for coding guide.
| Model | Parameters | Ollama download | Fits on | License |
|---|---|---|---|---|
| Qwen3-Coder 30B-A3B | 30.5B (3.3B active) | 19 GB (qwen3-coder:30b) | One 24GB GPU | Apache 2.0 |
| Qwen3-Coder-Next | 80B (3B active) | 52 GB (qwen3-coder-next) | 2× 32GB GPU, one 80GB GPU, 64GB+ Mac | Apache 2.0 |
| Qwen3-Coder 480B-A35B | 480B (35B active) | 290 GB (qwen3-coder:480b) | 4× 80GB GPU, 512GB Mac Studio | Apache 2.0 |
| Qwen 2.5 Coder 32B | 32B (dense) | 20 GB (qwen2.5-coder:32b) | One 24GB GPU | Apache 2.0 |
| Devstral Small | 24B (dense) | 14 GB (devstral:24b) | One 16-24GB GPU | Apache 2.0 |
| GPT-OSS 120B | 117B (5.1B active) | 65 GB (gpt-oss:120b) | One 80GB GPU, 96GB+ Mac | Apache 2.0 |
Choose the 30B-A3B When:
- • You have a single 24GB GPU or a 32GB+ Mac
- • You want fast completions and agent loops on local hardware
- • You use Cline, Qwen Code, Continue or Aider with a local endpoint
- • Privacy-sensitive code that can't go to the cloud
- • Apache 2.0 license requirements
Choose the 480B Flagship When:
- • You have server GPUs (4-8× H100/A100) or a 512GB Mac Studio
- • Maximum quality matters more than hardware cost
- • Complex multi-file refactoring across large codebases
- • You want to serve a whole team from one self-hosted endpoint
- • You are replacing a hosted coding API with a self-hosted model
Between the two sits Qwen3-Coder-Next: 52GB at Q4, so it needs 64GB of memory, with a published 70.6% SWE-bench Verified (SWE-Agent).
Use Cases
Agentic Software Engineering
Autonomous bug fixing and feature work in an agent such as OpenHands, Cline or Qwen Code. The 480B scored 69.6% on SWE-bench Verified with OpenHands in Qwen's announcement, meaning it resolved about 7 in 10 of those real GitHub issues in that harness.
Local AI Coding Assistant
Replace a hosted assistant with a private, self-hosted one. The 30B works with Continue.dev, Aider and any OpenAI-compatible editor plugin through Ollama's API on a single 24GB GPU.
Code Review & Refactoring
Load large parts of a repository (256K native context) and ask for bugs, security issues and refactors. Long contexts need memory for the KV cache, so budget for it.
Multi-Language Development
Trained on 7.5T tokens with a 70% code ratio. The 480B scores 88.00 on MultiPL-E, a multi-language version of HumanEval, in the Qwen3-Coder-Next technical report.
Terminal Automation
Shell commands, DevOps scripts and system administration through an agent with tool calls. For terminal-heavy work, compare Terminal-Bench 2.0 scores in the table above before choosing.
Enterprise Code Migration
Use the 480B with a long context (up to 1M tokens with YaRN) to analyze and migrate legacy codebases: framework upgrades, API migrations and language conversions.
Advanced Setup
Custom Modelfile for Coding Tasks
# Save as Modelfile.qwen3-coder FROM qwen3-coder:30b PARAMETER temperature 0.7 PARAMETER top_p 0.8 PARAMETER top_k 20 PARAMETER repeat_penalty 1.05 # 32K context fits a 24GB GPU next to the 19GB weights (~3GB KV cache) PARAMETER num_ctx 32768 SYSTEM """You are an expert software engineer. When given a task: 1. Analyze the existing code structure 2. Plan your changes before implementing 3. Write clean, tested, production-ready code 4. Explain key decisions briefly Always follow existing code conventions and patterns."""
Sampling values follow the recommended settings on the Qwen3-Coder model cards (temperature 0.7, top_p 0.8, top_k 20, repetition penalty 1.05).
Multi-GPU Setup for 480B
# vLLM on 8× H100 80GB with the official FP8 weights (~480GB)
pip install -U vllm
vllm serve Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 \
--tensor-parallel-size 8 \
--max-model-len 131072 \
--enable-auto-tool-choice \
--tool-call-parser qwen3_xml \
--port 8000Using with Aider (Coding Agent)
# Install Aider
pip install aider-chat
# Point Aider at your local Ollama instance
export OLLAMA_API_BASE=http://localhost:11434
# Start a coding session with the 30B
aider --model ollama_chat/qwen3-coder:30b
# Or use the 480B served by vLLM (OpenAI-compatible)
aider --model openai/Qwen/Qwen3-Coder-480B-A35B-Instruct-FP8 \
--openai-api-base http://localhost:8000/v1 \
--openai-api-key dummySources
- Qwen3-Coder-30B-A3B-Instruct on Hugging Face — Parameters, experts, layers, context, licence
- Qwen3-Coder-480B-A35B-Instruct on Hugging Face — Model weights and technical specifications
- Qwen Blog: Qwen3-Coder announcement (July 22, 2025) — Training data (7.5T tokens, 70% code) and the 480B benchmark chart
- Qwen3-Coder-Next Technical Report (arXiv 2603.00729, February 2026) — Same-scaffold SWE-bench, Terminal-Bench and coding tables, including the 480B
- QwenLM/Qwen3-Coder GitHub Repository — Official code, model list and documentation
- Qwen3-Coder on Ollama Library — Tags and download sizes (read November 2, 2026)
Frequently Asked Questions
What is Qwen3-Coder and who made it?
Qwen3-Coder is the Alibaba Qwen team's coding model family. The 480B-A35B flagship was released on July 22, 2025 and the smaller 30B-A3B on July 31, 2025. Both are Mixture-of-Experts models trained on 7.5 trillion tokens with a 70% code ratio, according to Qwen's announcement, and both are aimed at agentic coding: reading a repository, editing files and calling tools. A third model, Qwen3-Coder-Next (80B total, 3B active), followed in early 2026 and has its own page.
Which Qwen3-Coder should I run on my computer?
For almost everyone, qwen3-coder:30b. Ollama lists it at 19GB (Q4_K_M), so it fits a single 24GB GPU such as an RTX 3090 or 4090, or a Mac with 32GB of unified memory, with a few GB left for context. The 480B is 290GB at Q4_K_M, which means four 80GB data-center GPUs or a 512GB Mac Studio. If you have 64GB or more, also look at Qwen3-Coder-Next (52GB), which has a published 70.6% SWE-bench Verified score.
How much VRAM does Qwen3-Coder 30B need?
The weights are 19GB at Q4_K_M, 32GB at Q8_0 and 61GB at FP16, as listed in the Ollama library. On top of that comes the KV cache: the model has 48 layers with 4 KV heads of 128 dimensions, which works out to about 96KB per token at FP16, or roughly 3GB for a 32K context and 12-13GB for 128K. So a 24GB card runs Q4_K_M with a 32K context comfortably; the full 256K context needs far more memory.
Is Qwen3-Coder-Next the same model?
No. Qwen3-Coder-Next is a separate 80B model with 3B active parameters and a hybrid Gated DeltaNet + attention architecture, released in early 2026. It is bigger than the 30B (52GB at Q4 in Ollama) and has its own benchmark table from its technical report. See our Qwen3-Coder-Next page for its hardware and setup.
What context length does Qwen3-Coder support?
Both the 30B-A3B and the 480B-A35B support 262,144 tokens (256K) natively and up to 1M tokens with YaRN scaling, according to their Hugging Face model cards. In practice the context you can use is limited by memory for the KV cache, not by the model.
How do I run Qwen3-Coder with Ollama?
Run `ollama pull qwen3-coder:30b` (the default `qwen3-coder` tag is the same 19GB build), then `ollama run qwen3-coder:30b`. Other tags that exist in the Ollama library: qwen3-coder:30b-a3b-q8_0 (32GB), qwen3-coder:30b-a3b-fp16 (61GB), qwen3-coder:480b (290GB, Q4_K_M), qwen3-coder:480b-a35b-q8_0 (510GB) and qwen3-coder:480b-a35b-fp16 (960GB).
Is Qwen3-Coder open source?
Yes. Both Qwen3-Coder-480B-A35B-Instruct and Qwen3-Coder-30B-A3B-Instruct are published on Hugging Face under the Apache 2.0 license, which allows commercial use, modification and redistribution. Qwen3-Coder-Next is Apache 2.0 as well.
What are Qwen3-Coder's benchmark scores?
Qwen's July 2025 announcement chart gives the 480B 69.6% on SWE-bench Verified with OpenHands at 500 turns. The Qwen3-Coder-Next technical report (arXiv 2603.00729) lists the 480B at 44.93 on LiveCodeBench v6, 86.66 on EvalPlus, 88.00 on MultiPL-E and a Codeforces rating of 1800. For the 30B-A3B, Qwen published its scores only as a chart image, but the official swebench.com board lists it at 51.6% on SWE-bench Verified inside the OpenHands agent. Qwen3-Coder-Next scores 70.6% Verified with SWE-Agent and 71.3% with OpenHands in its report.
Ready to Go Beyond Tutorials?
25 structured courses with hands-on chapters - build RAG chatbots, AI agents, and ML pipelines on your own hardware.
Related Guides
Continue your local AI journey with these comprehensive guides
Go from reading about AI to building with AI
25 structured courses. Hands-on projects. Runs on your machine. Start free.

Written by
Barsha Mohapatra
Founder and Editor, Local AI Master · Founder, Little AI Master
Founder of Little AI Master and the editor behind every course and guide on Local AI Master. Years of tutoring students taught her where AI education actually fails.
- PILLARLocal AI Hardware Requirements (2026): Complete Guide
- Best Mac for Local AI: Every Apple Silicon Chip Ranked M1–M6
- Ollama System Requirements: Minimum RAM, GPU, Disk Size
- Run an LLM on Your Phone: Offline AI on Android & iPhone
- Llama 3.1 Nemotron 70B Instruct: Ollama, VRAM, Chat Template
- Llama 2 13B & 7B: Specs, VRAM, Ollama (llama2:13b)
- Gemma 4 Hardware Requirements: VRAM/RAM per Model
- Ollama Uncensored Models: Abliterated Picks by VRAM (2026)
- WizardLM 13B: Evol-Instruct, MMLU 54.6%, 8GB VRAM (Q4)
- Every CPU With an NPU: TOPS Ranking Table
Grab the AI Starter Kit — career roadmap, cheat sheet, setup guide
No spam. Unsubscribe with one click.
Found your model? Now build something with it.
25 hands-on courses — RAG, agents, fine-tuning — all running locally. First chapter free, no card.