Qwen2.5-Coder-32B-Instruct

Qwen2.5-Coder-32B-Instruct

Writes, explains and fixes code as the largest instruction-tuned model in the Qwen2.5-Coder family, at 32B parameters. For developers who run a strong open coding model on their own hardware.

Made by Qwen on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: Qwen2.5-Coder-32B-Instruct is the 32B instruction-tuned model of the Qwen2.5-Coder series, which was formerly called CodeQwen. It targets code generation, code reasoning and code fixing. The card says its training grew to 5.5 trillion tokens, including source code and text-code pairs.

Who it suits: Developers and teams who want a large open coding model they host themselves, for completion, review and agent-style work.

Industry | Who uses it | How they use it | Example
Software | Developers | Generate and fix code with a local model | Ask for a quick sort routine
Dev tooling | Tool builders | Power a code agent with an open model | Wire it into an agent that edits files
Education | Learners | Get explanations of code and algorithms | Ask why a function fails

If you have no GPU with plenty of memory, the card's smaller Coder sizes may suit you better.

Where to use it:

• Your own computer or server with Python and the transformers library
• vLLM, which the card recommends for deployment
• Qwen Chat, the hosted chat the card links

Use case | Who | What they get back
Code generation | Developers | Working code from a plain request
Code fixing | Developers | A corrected version of broken code
Code agents | Tool builders | A model that can drive agent workflows

How to set it up:

• Python with pip
• A recent transformers release, since versions below 4.37.0 fail with a KeyError for qwen2
• About 65.5 GB of disk space for the BF16 weights, or about 16.4 GB at 4-bit (an estimate)

1. Install the Hugging Face hub tool.
2. Download the model files.
3. Run the card's Python snippet, which loads the tokenizer and model and generates a reply.

pip install -U huggingface_hub
hf download Qwen/Qwen2.5-Coder-32B-Instruct

How to use it: Format a system and a user message with the chat template, then generate. This is the card's snippet, which asks for a quick sort algorithm.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Qwen/Qwen2.5-Coder-32B-Instruct"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

prompt = "write a quick sort algorithm."
messages = [
    {"role": "system", "content": "You are Qwen, created by Alibaba Cloud. You are a helpful assistant."},
    {"role": "user", "content": prompt}
]
text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True
)
model_inputs = tokenizer([text], return_tensors="pt").to(model.device)

generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=512
)
generated_ids = [
    output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
]

response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]

For inputs longer than 32,768 tokens, the card says to add a YaRN setting to config.json, for frameworks that support it.

{
  ...,
  "rope_scaling": {
    "factor": 4.0,
    "original_max_position_embeddings": 32768,
    "type": "yarn"
  }
}

Example: You run the snippet as it is, which asks the model to write a quick sort algorithm. The variable response holds the model's code answer, up to 512 new tokens.

For newcomers and experts: If you are new, run the snippet above and change the prompt to a small coding task of your own. Check your GPU memory first, as the weights are large.

For experts, the model has 64 layers with 40 query heads and 8 key-value heads. The default config handles 32,768 tokens, and YaRN stretches it toward the full 131,072. The card notes vLLM applies static YaRN, which may hurt performance on shorter texts.

You send a coding request
The chat template formats the messages
The model generates code and explanation
You decode the reply and review it

Good to know: The card says the YaRN setting should only be added when you need long inputs.

Title: Qwen2.5-Coder-32B-Instruct figures from the card
Layers: 64 layers
Parameters: 32.5 billion
Non-embedding parameters: 31.0 billion
Full context: 131072 tokens

• License: Apache 2.0, as the Hugging Face record lists it.
• Cost to run: no API key or account is named. You need hardware that can hold the weights.
• Data it reaches: downloading reaches Hugging Face. The snippet does not describe reaching other files or the web.
• Not for: the card names no banned uses. Static YaRN may lower quality on short texts, so enable it only for long inputs.

On Hugging Face, 13 November 2026

• Task: text generation
• Library: transformers
• Parameters: 32.8B
• Weights: about 65.5 GB in BF16; about 16.4 GB at 4-bit (estimate)
• Formats: Safetensors
• Downloads in the last 30 days: 546,583
• Likes: 2,211
• License: apache-2.0
• Languages: en
• Based on: Qwen/Qwen2.5-Coder-32B
• Quantized versions: 141
• Fine-tunes: 156
• Tags: transformers, safetensors, qwen2, text-generation, code, codeqwen, chat, qwen, qwen-coder, conversational

Links

• Model: https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct
• Files: https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download Qwen/Qwen2.5-Coder-32B-Instruct

Then follow the usage in its model card. Nothing in this kit runs by itself.