Qwen2.5 Coder 32B Instruct: The Dense Coder You Can Still Own

Qwen2.5 Coder 32B Instruct was, for a while, the answer to a specific question: what is the best coding model I can run on my own hardware without a licence lawyer? Qwen published it in November 2024 and claimed it matched GPT-4o on several coding benchmarks. That claim was about the closed model of its day, and the field has moved a long way since.

It is still worth understanding, for two reasons. Plenty of self-hosted setups and fine-tunes are built on it, and its shape — a dense, mid-sized, permissively licensed coder — remains a useful reference point when you evaluate newer options.

What Qwen actually published

The model card describes a 32.5B-parameter dense transformer (31.0B non-embedding) with 64 layers and grouped-query attention using 40 query heads and 8 key-value heads. The Coder line was trained on 5.5 trillion tokens of source code, text-code grounding data and synthetic data. It is published under Apache 2.0, as are all the Coder sizes except 3B, which uses the Qwen Research licence.

Qwen's launch post put three numbers in text rather than in charts, and they are the ones worth quoting:

• Aider — 73.7, which Qwen described as comparable to GPT-4o at the time.
• McEval — 65.9, a multi-language code generation benchmark.
• MdEval — 75.2, a multi-language code repair benchmark, which Qwen said ranked first among open models.

The post also claims support for more than 40 programming languages and leading open-model results on EvalPlus, LiveCodeBench and BigCodeBench, without giving those scores in text. All of this is vendor-run and dates from late 2024, so read it as a statement about that cohort rather than about today.

Why the Aider number is the interesting one

Most code benchmarks ask a model to write a function from a docstring. Aider's benchmark asks it to edit existing code in a format a tool can apply, which is much closer to how coding assistants actually work. A model can be good at writing fresh code and still be poor at producing a clean diff against a file it has to read first.

A strong Aider score, plus the code-repair emphasis in MdEval, suggests this model was tuned for fixing and editing as much as generating. If you plan to drive it through an editing tool, the Aider setup guide shows how to point Aider at any OpenAI-compatible endpoint so you can reproduce the test on your own code.

Two limits to plan around

Context is 32K unless you change it

The card advertises 131,072 tokens, but the shipped configuration covers 32,768; reaching the full window needs YaRN scaling with a factor of 4.0, which Qwen says can hurt short-input quality under vLLM's static implementation. OpenRouter lists the model at 32,768 tokens at the time of writing.

For a coding model that is the binding constraint. A single large file, its tests and a page of compiler output will fit. A multi-file refactor with surrounding context often will not. You will need retrieval or careful context selection to use it on anything repository-sized.

No tool calling listed on hosted endpoints

OpenRouter lists JSON mode but not tool calling for this model. That matters if you want to put it inside an agent loop that expects native function calls. You can still prompt it to emit a structured action and parse that yourself, but you are building the reliability layer rather than relying on the provider's.

For chat-driven coding, editing tools such as Aider, or a fixed pipeline that asks for a diff, neither limit is fatal. For an autonomous agent working across a large repository, both are.

Self-hosting arithmetic

This is where the model still has a real argument. At 32.5B parameters, the weights take roughly 65 GB in 16-bit precision, which means a pair of 48 GB cards or a single 80 GB card. Quantised to 8-bit it is around half that, and at 4-bit it fits on a single 24 GB consumer card with a short context, at some quality cost.

Dense also means predictable. Every token uses every parameter, so throughput scales simply with hardware and there is no expert-routing behaviour to profile. For a team that wants a private coding model on a known box, that simplicity is a feature.

Hosted, OpenRouter lists it at $0.66 per million input tokens and $1.00 per million output at the time of writing. That is no longer especially cheap for its capability level, which is the clearest sign that its main value now is as weights you own rather than as an API you rent.

Against its successors

Qwen has since released the Qwen3 Coder line, including a 30B mixture-of-experts model that, as the A3B in its name indicates, activates about 3B parameters per token. That changes the economics: similar total memory, far less compute per token, and a model a full generation newer. The Qwen3 Coder 30B A3B guide covers it.

A reasonable rule:

• Keep Qwen2.5 Coder 32B if you have a fine-tune or validated pipeline on it, your tasks are single-file edits, and the results are acceptable.
• Move to a newer coder if you need native tool calling, a longer working context, or agent-style multi-step work.

How to test it before committing

Pull ten bug fixes from your own git history, each confined to one or two files. Give the model the files, the failing test output and the issue text, and ask for a diff. Record whether the diff applies cleanly, whether the tests pass, and how many attempts it took. Run the same set against whichever newer model you are considering.

If the old model's diffs apply and pass at a similar rate, the newer model has to win on cost or context to justify the switch. How to benchmark LLMs on your own work covers setting up that comparison so it is fair.