Which Qwen model to run: versions, sizes and VRAM

The Qwen model you can run depends on your GPU memory. At Q4_K_M with an 8K context, Qwen3.5 9B needs 6.8 GB, Qwen3.8 27B 17.2 GB, Qwen3 Next 80B-A3B 46.5 GB and Qwen3 Coder 480B-A35B 273.1 GB. These are single-request figures for the 11 family models in the gpu.nz calculator. Below: what separates the generations, which model fits which card and how to run it on a rented GPU.

Which Qwen models are there?

Qwen is Alibaba's family of open models. The names are easy to mix up: versions, sizes and suffixes all run together. Five lines matter for a GPU in our data.

• Qwen3 — dense models at 8B, 14B and 32B plus two Mixture-of-Experts (MoE) models, 30B-A3B and 235B-A22B. They work with text and think before answering by default.
• Qwen3 Coder — programming models, 30B-A3B and 480B-A35B. The authors built them for agentic coding, and they have no thinking mode.
• Qwen3 Next 80B-A3B — a MoE with 81.3B parameters, 3B of them working on each token. Its attention is hybrid, more on that below.
• Qwen3.5 — the 4B and 9B versions are in the table. They take images along with text.
• Qwen3.8 27B — the newest in the table. Its authors call it the next generation after Qwen3.5 and Qwen3.6, with gains in code, professional work and agents. It takes images and video.

“A3B” and “A22B” mean 3B and 22B active parameters. In a dense model every parameter works on every token.

Part of the family is not in the calculator yet: Qwen3.5 has 27b, 35b and 122b sizes in the Ollama library, Qwen3.8 has Flash-Next and 2.4T-A95B on Hugging Face, and Qwen3.6 is not in the data. We do not count these.

How much VRAM does each Qwen model need?

At Q4_K_M and an 8K context, from 4.1 GB (Qwen3.5 4B) to 273.1 GB (Qwen3 Coder 480B-A35B). Quantisation compresses the weights: the Q4_K_M file of Qwen3.8 27B is 3.3 times smaller than the original BF16, with little loss in answer quality. The total covers the weights, the context cache (memory for the text the model has already read) and the CUDA runtime.

The whole family in one table: parameters, file size, memory at two context lengths, the smallest card and the context limit set in each model's config.

How do Qwen3.5 and Qwen3.8 differ from Qwen3?

The biggest difference shows in memory: the new models have a much smaller context cache. In Qwen3 every layer keeps the whole conversation. In Qwen3.8 27B and Qwen3.5 9B (according to the model cards) three layers in four are linear attention, Gated DeltaNet, with a tiny state. Only every fourth layer keeps a cache. That is 64 KiB per token against 256 KiB for Qwen3 32B, 4 times less.

Qwen3 Next is built like Qwen3.8, and Qwen3 Coder like plain Qwen3. The gap widens with long contexts. Qwen3.8 27B at 128K needs 24.7 GB and stays on a 32 GB card; at the full 256K it takes 32.7 GB and a 48 GB card. Qwen3 Coder 30B-A3B at 128K needs 30.3 GB for 17.3 GB of weights: its cache is the ordinary kind.

The new models take 256K tokens of context, about 400 pages of text. Qwen3 is limited to 40K in our data. The Qwen3 cards say YaRN stretches it to 128K, with a warning that quality on short texts can drop. The calculator does not model that mode.

We have not measured answer quality in Russian or any other language. The authors claim support for more than 100 languages in Qwen3 and 201 in Qwen3.5. Try the model on your own texts: on a rented card that is an hour of work.

Which Qwen model fits your GPU?

The table shows which models each next memory step adds at 8K, 32K and 128K context (Q4_K_M, one request). A dash means nothing new.

• 8 GB — Qwen3.5 9B: 6.8 GB at 8K and 7.6 GB at 32K. Qwen3 8B fits at 8K too, but for 32K it needs a 12 GB card.
• 12 GB and 16 GB — Qwen3 14B: 10.7 GB at 8K. A 32K context (14.4 GB) needs a 16 GB card.
• 24 GB — the widest step: Qwen3.8 27B (17.2 GB), Qwen3 30B-A3B and Coder 30B-A3B (19.1 GB), Qwen3 32B (21.4 GB). All but Qwen3 32B hold a 32K context.
• 32 GB — Qwen3 32B with a 32K context (27.4 GB) and Qwen3.8 27B with 128K (24.7 GB).
• 48 GB — Qwen3 Next 80B-A3B: 46.5 GB, almost the whole card. A 32K context no longer fits and needs an 80 GB card.

Within one line, more parameters usually mean better answers. We have no quality comparison across lines: take two or three models that fit and run them on your own tasks.

Check your own setup

Pick the model, quantisation and context length: the calculator shows the memory and the catalog GPUs that run it for the least money.

Which Qwen for code, chat and images?

• Code in an editor, agents — Qwen3 Coder. The 30B-A3B needs 19.1 GB and runs on a 24 GB card; the 480B-A35B needs several cards.
• Chat, writing, analysis — Qwen3.8 27B (24 GB), or Qwen3.5 9B on a smaller card. Both think by default.
• Images as input — Qwen3.5 and Qwen3.8: attach a photo or a screenshot. Qwen3 and Coder take text only.
• An API for several people — MoE models such as 30B-A3B and Next: fewer parameters work on each token than in a dense model of the same size. vLLM suits such an API.
• Image generation — a different family, Qwen-Image. Setup and use are in Qwen-Image-Edit in ComfyUI.
• Versions without refusals — ready templates for Qwen3.8 27B uncensored (24 GB card) and Qwen3 14B uncensored (from a 12 GB card).

How many GPUs do Qwen3 235B and Coder 480B need?

The big ones do not fit an ordinary card. Qwen3 235B-A22B at Q4_K_M needs 134.9 GB: almost the whole 141 GB card. Qwen3 Coder 480B-A35B needs 273.1 GB: one 288 GB card or several smaller ones.

The model is split across cards: the calculation halves the weights and the cache, and every card keeps its own runtime memory. Servers with several cards are not always in the catalog. The calculator above lists only those available now.

How to run Qwen on a rented GPU

No suitable card of your own? Rent a GPU server for the hours you need it. Qwen3.8 27B has a ready template with a chat and an API; Ollama handles the other models.

1. 1

   Pick a card from the table above

   Qwen3.8 27B needs a 24 GB card: an RTX 3090 or RTX 4090 from the catalog. Qwen3.5 9B is fine on 8 GB.

2. 2

   Choose a template

   For Qwen3.8 27B use the Qwen 3.8 template: the model, a chat and an API are ready without setup. For the others, use Open WebUI + Ollama and type a tag into the Model field, such as qwen3.5:9b, qwen3:14b or qwen3-coder:30b.

3. 3

   Wait 2–5 minutes

   The server starts and the model downloads on first start. Bigger models take longer.

4. 4

   Open the chat

   The Open WebUI button on the server page opens the chat. The OpenAI-format API runs on the same server; request examples are in Qwen API on your own server.

5. 5

   Add another model if you need it

   Pull it in the chat or over SSH, with no new server.

   ollama pull qwen3.5:9b

6. 6

   Stop the server when you are done

   Billing is per minute: a stopped server costs nothing for the GPU, only its disk.

For the big models and for an API with several users, use vLLM. This is how the model card runs Qwen3 Next 80B-A3B: four cards, a 256K context, vLLM 0.10.2 or newer.

vllm serve Qwen/Qwen3-Next-80B-A3B-Instruct --port 8000 --tensor-parallel-size 4 --max-model-len 262144

--tensor-parallel-size sets the number of cards and --max-model-len the context length. The template starts a different model by default; the template page explains how to switch without leaving the API open.

What can go wrong

• Thinking uses up context. Qwen3, Qwen3.5 and Qwen3.8 think first by default, and long reasoning grows the cache. In Qwen3 and Qwen3.5 you can switch it off with enable_thinking=False. Coder has no thinking.
• Parallel requests multiply the cache. The figures above are for one request. In vLLM every concurrent request keeps its own cache, so an API for several people needs headroom.
• A tight fit. Above 92% of the card's memory the model starts, but a long conversation will not fit. The table marks Qwen3 Next 80B-A3B, Qwen3 235B-A22B and Qwen3 Coder 480B-A35B this way.
• Ollama tags are different builds. The size of a tag in the Ollama library differs a little from the Q4_K_M GGUF in our data. If the fit is tight, take the next card size.
• Licences differ. The cards of Qwen3.8 27B, Qwen3.5 9B, Qwen3 32B and 235B, Next and Coder say Apache-2.0, while Qwen3.8 Flash-Next says qwen-community-1.0. Open the card of your model before a commercial launch.

How we counted

Weights are the real file sizes: GGUF from Hugging Face, BF16 from Qwen's original repositories. The context cache is computed from each model's config.json, counting the linear layers of the hybrid models. The runtime is about 0.75 GB plus the logits buffer. A card counts as enough when the model takes at most 97.5% of its memory. 1 GB here is 1024³ bytes, as on GPUs. Data as of 2026-10-19; the method is in the calculator, and one table for 35 models is in How much VRAM do open LLMs really need?. Ollama tags by memory step are in the Ollama model roundup, and a neighbouring read is Gemma 4: which version fits.