★ Reading this for free? Get 25 structured AI courses + per-chapter AI tutor — the first chapter of every course free, no card.Start free in 30 secondsOr own every course: $149 once

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.

MoE ArchitectureCoding Specialist

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.

📅 Published: March 18, 2026🔄 Last Updated: November 2, 2026✓ Manually Reviewed
30.5B / 480B
Total Parameters
3.3B / 35B
Active Parameters
19GB / 290GB
Ollama Q4_K_M
256K (1M YaRN)
Context Length

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.

Specification30B-A3B480B-A35B
Total Parameters30.5B480B
Active per Token3.3B35B
Expert Count128 (8 active)160 (8 active)
Layers4862
Attention heads (Q / KV)32 / 496 / 8
Context Length262K (1M with YaRN)262K (1M with YaRN)
Training Tokens7.5T (70% code), family figure7.5T (70% code)
ArchitectureMoE TransformerMoE Transformer
LicenseApache 2.0Apache 2.0
Release DateJuly 31, 2025July 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-A35BCoder-NextDeepSeek-V3.2GLM-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 v644.9358.93——
EvalPlus86.6686.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

VariantQuantization (Ollama tag)WeightsHardware Example
30B-A3BQ4_K_M (qwen3-coder:30b)19 GBRTX 3090/4090 24GB with a 32K context; 32GB Mac
30B-A3BQ8_0 (qwen3-coder:30b-a3b-q8_0)32 GB48GB GPU (RTX 6000 Ada, 2× 24GB), 48GB+ Mac
30B-A3BFP16 (qwen3-coder:30b-a3b-fp16)61 GB80GB GPU (H100/A100), 96GB Mac
480B-A35BQ4_K_M (qwen3-coder:480b)290 GB4× H100 80GB (320GB, little room for context), 512GB Mac Studio
480B-A35BQ8_0 (qwen3-coder:480b-a35b-q8_0)510 GB8× H100 80GB
480B-A35BFP16 (qwen3-coder:480b-a35b-fp16)960 GB8× 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.

ModelParametersOllama downloadFits onLicense
Qwen3-Coder 30B-A3B30.5B (3.3B active)19 GB (qwen3-coder:30b)One 24GB GPUApache 2.0
Qwen3-Coder-Next80B (3B active)52 GB (qwen3-coder-next)2× 32GB GPU, one 80GB GPU, 64GB+ MacApache 2.0
Qwen3-Coder 480B-A35B480B (35B active)290 GB (qwen3-coder:480b)4× 80GB GPU, 512GB Mac StudioApache 2.0
Qwen 2.5 Coder 32B32B (dense)20 GB (qwen2.5-coder:32b)One 24GB GPUApache 2.0
Devstral Small24B (dense)14 GB (devstral:24b)One 16-24GB GPUApache 2.0
GPT-OSS 120B117B (5.1B active)65 GB (gpt-oss:120b)One 80GB GPU, 96GB+ MacApache 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 8000

Using 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 dummy

Sources

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.

🎯
AI Learning Path

Go from reading about AI to building with AI

25 structured courses. Hands-on projects. Runs on your machine. Start free.

Or own it for life — Lifetime $149 $599, pay once
Barsha Mohapatra

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.

More on Local AI Hardware
See the full AI Hardware Guide 2026 guide.
📚
Free · no account required

Grab the AI Starter Kit — career roadmap, cheat sheet, setup guide

No spam. Unsubscribe with one click.

🎯
AI Learning Path

Found your model? Now build something with it.

25 hands-on courses — RAG, agents, fine-tuning — all running locally. First chapter free, no card.

Or own it for life — Lifetime $149 $599, pay once
Free Tools & Calculators