AI-generated illustration
Information as of
AI & ChipsQwen 3.6 27B: License, Benchmarks and Memory Needed to Run It
Qwen3.6-27B is a 27-billion-parameter open-weight model from Alibaba’s Qwen team, published on April 22, 2026. It remains one of the most-downloaded mid-size models for running on a single machine. This report checks the basics people search for against Qwen’s own files: the license, context length, Qwen’s benchmark table, and how much memory each common quantization needs.
TL;DR
- What it is. A dense 27B model with a vision encoder, a native context of 262,144 tokens (extensible to about 1.01 million with YaRN), and thinking mode on by default. The weights are licensed under the unmodified Apache License 2.0, which allows commercial use.
- What Qwen reports. On Qwen’s own table it scores 77.2 on SWE-bench Verified, above Qwen’s older 397B-parameter flagship (76.2) and below Claude 4.5 Opus (80.9). These are vendor numbers from Qwen’s own test setup.
- What it takes to run. Full BF16 weights are about 55.6 GB. 8-bit files are about 28–31 GB, and 4-bit files are about 16–19 GB. Unsloth lists 18 GB of total memory for 4-bit. A newer same-size model, Qwen3.8-27B, followed in August.
What Qwen3.6-27B is
The model card describes a “causal language model with vision encoder.” It accepts images as well as text. It is dense, meaning every parameter is used for every token. Its sibling, Qwen3.6-35B-A3B, is a mixture-of-experts (MoE) model that activates about 3B of its 35B parameters per token. Hugging Face’s metadata for the repository counts 27,781,427,952 parameters in BF16.
The architecture is a hybrid. According to the card, the 64 layers are arranged as 16 blocks, and each block has three Gated DeltaNet (linear attention) layers followed by one Gated Attention layer. Only one layer in four uses full attention. This is one reason long contexts cost less memory than they would in a conventional transformer of the same size. The model was also trained for multi-token prediction (MTP), which runtimes can use for speculative decoding.
Other details from the card:
- Context: 262,144 tokens natively, extensible to 1,010,000 tokens with YaRN rope scaling. Qwen notes that the open-source frameworks implement static YaRN, which may lower quality on short texts.
- Thinking: thinking mode is on by default and can be turned off per request. A new
preserve_thinkingoption keeps reasoning from earlier turns in the conversation, which Qwen pitches for agent workflows. - Qwen’s advice on context: if memory runs out, shrink the context window, but Qwen recommends keeping at least 128K tokens “to preserve thinking capabilities.”
- Official files: BF16 weights (55.56 GB across 15 safetensors files) and an official FP8 version (30.87 GB), on Hugging Face and ModelScope.
License: what Apache 2.0 allows
The repository’s LICENSE file is the standard Apache License 2.0 text with “Copyright 2026 Alibaba Cloud.” It matches the Apache Software Foundation’s published text line for line, and there is no separate Qwen license or acceptable-use addendum in the repo. In practice, under Apache 2.0:
- Commercial use, modification, fine-tuning and redistribution are permitted, with no user-count threshold.
- Anyone who redistributes the weights or a derivative must include a copy of the license, keep the notices, and mark files they changed.
- The license grants a patent license. That grant ends for anyone who files patent litigation claiming the work infringes.
- The license gives no rights to Qwen or Alibaba trademarks, and the model comes “as is,” without warranty.
The license covers the weights. It does not address the separate question of what the model outputs or how it behaves in a given jurisdiction. Businesses still need their own review of those.
Reported benchmarks
Qwen’s model card compares Qwen3.6-27B against five models. Every figure below is Qwen’s own, measured with Qwen’s harnesses. Independent reproductions may differ.
| Benchmark (Qwen reports) | Qwen3.6-27B | Qwen3.6-35B-A3B | Qwen3.5-27B | Qwen3.5-397B-A17B | Gemma4-31B | Claude 4.5 Opus |
|---|---|---|---|---|---|---|
| SWE-bench Verified | 77.2 | 73.4 | 75.0 | 76.2 | 52.0 | 80.9 |
| SWE-bench Pro | 53.5 | 49.5 | 51.2 | 50.9 | 35.7 | 57.1 |
| Terminal-Bench 2.0 | 59.3 | 51.5 | 41.6 | 52.5 | 42.9 | 59.3 |
| SkillsBench (avg of 5) | 48.2 | 28.7 | 27.2 | 30.0 | 23.6 | 45.3 |
| LiveCodeBench v6 | 83.9 | 80.4 | 80.7 | 83.6 | 80.0 | 84.8 |
| GPQA Diamond | 87.8 | 86.0 | 85.5 | 88.4 | 84.3 | 87.0 |
| MMLU-Pro | 86.2 | 85.2 | 86.1 | 87.8 | 85.2 | 89.5 |
| AIME 2026 | 94.1 | 92.7 | 92.6 | 93.3 | 89.2 | 95.1 |
| MMMU (vision) | 82.9 | 81.7 | 82.3 | 85.0 | 80.4 | 80.7 |
A few caveats come from Qwen’s own footnotes. The SWE-bench runs use an internal agent scaffold with a 200K context window. For SWE-bench Pro, Qwen corrected “some problematic tasks” and re-ran all the baselines on its revised set. SkillsBench covers a 78-task subset. The coding numbers where the 27B model beats Qwen’s 397B MoE are real on this table, but the knowledge and reasoning rows (MMLU-Pro, GPQA Diamond) still favor the larger model. For more on Gemma 4, one of the named peers, see our Gemma 4 report.
Running it locally: memory by quantization
Quantization stores each weight in fewer bits, which shrinks the file and the memory it needs. The table puts three kinds of numbers side by side, and each column is labeled with where it comes from.
| Precision | SignalStack arithmetic (27.78B × bits ÷ 8, weights only) | Published file sizes | Unsloth’s stated total memory |
|---|---|---|---|
| BF16 (16-bit) | 55.6 GB | 55.56 GB (Qwen, Hugging Face); 55–56 GB (Ollama) | 55 GB |
| 8-bit | 27.8 GB | 30.87 GB FP8 (Qwen); 28.6 GB Q8_0 (Unsloth GGUF); 29.5 GB (MLX 8-bit); 30 GB q8_0 (Ollama) | 30 GB |
| 6-bit | 20.8 GB | 22.52 GB Q6_K (Unsloth GGUF) | 24 GB |
| 4-bit | 13.9 GB | 16.82 GB Q4_K_M (Unsloth GGUF); 16.05 GB (MLX 4-bit); 17 GB q4_K_M (Ollama) | 18 GB |
| 3-bit | 10.4 GB | 13.59 GB Q3_K_M (Unsloth GGUF) | 15 GB |
The simple arithmetic understates real files. Quantization formats keep some tensors, such as embeddings and scales, at higher precision, and runtimes also need room for the KV cache, which grows with the context window. Unsloth’s figures count RAM plus VRAM, or unified memory on a Mac. Unsloth says total memory should exceed the file size for good speed, and that MTP builds need about 1 GB more.
Reported real-world runs, each attributed to its author:
- Simon Willison ran Unsloth’s 16.8 GB Q4_K_M file with llama.cpp’s
llama-serverat a 65,536-token context. He reported about 25.6 tokens per second of generation. - Quesma tested 8-bit builds on a MacBook M5 Max with 128 GB and a 64K context. It reported 17 tokens/s with MLX (28 GB RAM), 18 tokens/s with llama.cpp (41 GB), and 32 tokens/s with llama.cpp plus MTP (42 GB).
- InsiderLLM’s guide says a 24 GB GPU runs Unsloth’s UD-Q4_K_M build cleanly. On a 16 GB GPU, the guide says you need a 3-bit build or partial offload of the KV cache.
Where to get it: the official weights are on Hugging Face and ModelScope. Ollama lists qwen3.6:27b (an 18 GB download with a 256K context). GGUF builds for llama.cpp and LM Studio come from Unsloth and ggml-org, and MLX builds for Apple silicon come from mlx-community. For servers, the card gives vLLM and SGLang commands. Its reference setup serves the full 262,144-token context with tensor parallelism across 8 GPUs, which says more about full-context serving than about desktop use. For a look at the other end of the hardware range, see our report on tinybox and tinygrad.
Background
Qwen released the Qwen3.5 series in February 2026. Qwen3.6 arrived in pieces: the 35B-A3B MoE weights appeared on Hugging Face in mid-April, a cloud-only Qwen3.6-Max-Preview followed on April 20, and the dense 27B landed on April 22, according to InsiderLLM’s timeline. The 27B card says the release focuses on “stability and real-world utility” for coding. As of this update, Hugging Face counts about 2.6 million downloads of the official repository in the past month.
It is no longer the newest model of its size. Qwen published Qwen3.8-27B in August 2026, also under Apache 2.0. Its model card lists the same 64-layer layout and the same 262,144-token native context, now extensible to 1,000,000 tokens. Coverage by Kingy AI reports that Qwen’s 3.8 card shows gains over 3.6 on every text benchmark displayed. Anyone choosing a model today can use the memory table above as a rough guide for Qwen3.8-27B as well, since the parameter count is the same. Coverage of other AI launches is in our AI & Semiconductors section.
What could go right / What could go wrong
What could go right
- A permissive license and a model that fits on one machine let teams keep code and documents on hardware they control, without per-token API fees.
- Runtime support keeps improving. InsiderLLM reports that llama.cpp merged native MTP support for Qwen3.6 in May, and Quesma’s MTP run was nearly twice as fast as the plain llama.cpp run.
What could go wrong
- The benchmark lead rests mostly on Qwen’s own scaffolds and a SWE-bench Pro set that Qwen itself revised. Results in other agent harnesses may be lower.
- Local speed is modest. The reported runs sit in the high teens to low 30s of tokens per second, and thinking mode spends many of those tokens on reasoning before the answer.
- Aggressive 3-bit or 2-bit builds fit smaller GPUs, but quality at those levels is not covered by Qwen’s benchmark table.
- Newer releases, including Qwen3.8-27B, mean tutorials and tooling may shift away from 3.6.
FAQ
Q Is Qwen 3.6 27B free for commercial use?
A Yes. The weights are released under the standard Apache License 2.0 (copyright Alibaba Cloud), which allows commercial use, modification and redistribution. You must keep the license and notices, and it grants no trademark rights.
Q How much VRAM do I need to run Qwen 3.6 27B?
A Unsloth lists about 18 GB of total memory for 4-bit, 24 GB for 6-bit, 30 GB for 8-bit and 55 GB for full BF16. Longer contexts need extra memory for the KV cache.
Q What is the context length of Qwen3.6-27B?
A Qwen's model card lists 262,144 tokens natively, extensible to 1,010,000 tokens with YaRN scaling. Qwen recommends keeping at least 128K tokens to preserve thinking quality.
Q Is Qwen 3.6 27B better than Qwen 3.6 35B-A3B?
A On Qwen's own table, the dense 27B scores higher on coding benchmarks, for example 77.2 against 73.4 on SWE-bench Verified. The 35B-A3B MoE runs faster: in Quesma's 8-bit tests on the same Mac it generated about three to five times as many tokens per second.
Q Where can I download Qwen3.6-27B?
A Official BF16 and FP8 weights are on Hugging Face (Qwen/Qwen3.6-27B) and ModelScope. Quantized builds are in Ollama (qwen3.6:27b), in Unsloth and ggml-org GGUF repositories, and in mlx-community for Apple silicon.
Companies in this report: Alibaba
Sources
- Qwen3.6-27B model card
- Qwen3.6-27B LICENSE (Apache License 2.0)
- Qwen3.6-27B-FP8 weights
- Qwen3.6-27B (ModelScope)
- Qwen3.8-27B model card
- Qwen3.6-27B GGUF files
- Qwen3.6: how to run locally
- qwen3.6 tags
- Qwen3.6-27B MLX 4-bit
- Qwen3.6-27B MLX 8-bit
- Qwen3.6-27B: Flagship-Level Coding in a 27B Dense Model (link post)
- Qwen 3.6 27B is the sweet spot for local development
- Qwen3.6-27B: A Dense 27B Model That Beats a 397B MoE on Coding
- Qwen 3.6 Complete Guide: 27B Dense, 35B-A3B MoE, and Which to Use
- Qwen3.8-27B: Benchmarks, Specs, Local Hardware and Verdict