Qwen3.6 27B GPU requirements: 13.9 GB at 4-bit, 55.6 GB at BF16
Qwen3.6 27B needs 55.6 GB of GPU memory for its weights at BF16, 27.8 GB at FP8 and 13.9 GB at 4-bit, plus 2.15 GB of KV cache for a 32K context. The cheapest node that runs it here is 1× A30 at 4-bit, for $0.05 an hour on spot.
Weights plus a 32K 16-bit KV cache, with 10% of the node's memory kept free. Billed per minute.
- Parameters
- 27BDense
- Weights, 4-bit
- 13.9 GBBF16: 55.6 GB
- KV cache, 32K
- 2.15 GBOne sequence, 16-bit cache
- Context window
- 256KNative
How much VRAM Qwen3.6 27B needs, format by format.
Weights are parameters × bytes per parameter. Each context column adds the KV cache of one sequence of that length.
| Format | Weights | + 8Kcontext | + 32Kcontext | + 128Kcontext | + 256Kcontext | Cheapest node, 32K |
|---|---|---|---|---|---|---|
| BF16Published weights, fine-tuning | 55.6 GB | 56.1 GB | 57.7 GB | 64.1 GB | 72.7 GB | 1× A100 PCIe 80GB · $0.09/h |
| FP8Hopper, Ada, Blackwell, MI300 | 27.8 GB | 28.3 GB | 29.9 GB | 36.4 GB | 45.0 GB | 1× L40 · $0.09/h |
| 4-bitAWQ, GPTQ, GGUF Q4 | 13.9 GB | 14.4 GB | 16.0 GB | 22.5 GB | 31.1 GB | 1× A30 · $0.05/h |
The serving engine adds its own buffers, and an 8-bit KV cache halves the context columns. We keep 10% of a node's memory free when we say a model fits. Speed is a separate question: it follows memory bandwidth and, for a mixture of experts, the active parameters.
GPUs that run Qwen3.6 27B, cheapest first.
For each format, the smallest node of each GPU model that holds the weights and a 32K context, sorted by spot price. One row per GPU model; larger nodes of the same GPU work too.
| Format | GPU | GPU memory | Spot | On-demand | 730 h spot | Action |
|---|---|---|---|---|---|---|
| 4-bit | 1× A30Ampere · 16.0 GB needed | 24 GB | $0.05 | $0.08 | $36.50 | Deploy |
| 4-bit | 1× L4Ada Lovelace · 16.0 GB needed | 24 GB | $0.05 | $0.08 | $36.50 | Deploy |
| 4-bit | 1× RTX 3090Ampere · 16.0 GB needed | 24 GB | $0.05 | $0.08 | $36.50 | Deploy |
| 4-bit | 1× RTX 4000 AdaAda Lovelace · 16.0 GB needed | 20 GB | $0.06 | $0.09 | $43.80 | Deploy |
| FP8 | 1× L40Ada Lovelace · 29.9 GB needed | 48 GB | $0.09 | $0.19 | $65.70 | Deploy |
| FP8 | 1× RTX 6000 AdaAda Lovelace · 29.9 GB needed | 48 GB | $0.09 | $0.19 | $65.70 | Deploy |
| FP8 | 2× L4Ada Lovelace · 29.9 GB needed | 48 GB | $0.10 | $0.16 | $73.00 | Deploy |
| FP8 | 2× RTX 4000 AdaAda Lovelace · 29.9 GB needed | 40 GB | $0.12 | $0.18 | $87.60 | Deploy |
| BF16 | 1× A100 PCIe 80GBAmpere · 57.7 GB needed | 80 GB | $0.09 | $0.19 | $65.70 | Deploy |
| BF16 | 2× A40Ampere · 57.7 GB needed | 96 GB | $0.12 | $0.18 | $87.60 | Deploy |
| BF16 | 2× A100 40GBAmpere · 57.7 GB needed | 80 GB | $0.18 | $0.34 | $131.40 | Deploy |
| BF16 | 2× L40Ada Lovelace · 57.7 GB needed | 96 GB | $0.18 | $0.38 | $131.40 | Deploy |
Spot capacity can be reclaimed with a 2-minute notice; for a live endpoint, use on-demand. How spot works · serving a language model.
What a long context costs in memory.
Hybrid: 16 full-attention layers (4 KV heads of 256), the other 48 are linear-attention (Gated DeltaNet) layers with a fixed-size state.
| Context | KV cache, 1 sequence | 8 sequences |
|---|---|---|
| 8K tokens | 0.54 GB | 4.29 GB |
| 32K tokens | 2.15 GB | 17.2 GB |
| 128K tokens | 8.59 GB | 68.7 GB |
| 256K tokens | 17.2 GB | 137 GB |
Serving several users
KV cacheEvery concurrent request keeps its own cache, so memory for context grows with users × context length. A server batching 8 requests of 32K needs eight times the single-sequence figure — 17.2 GB here.
- Recommended node1× A30
- Weights at 4-bit13.9 GB
- Context that fits, 1 sequence115K
Paged attention (vLLM, SGLang) allocates the cache in blocks as requests grow, so a node holds more short requests than the worst case suggests.
Qwen3.6 27B, as published.
- Developer
- Alibaba QwenDense hybrid-attention Qwen3.6
- Parameters
- 27B27.8B in the published checkpoint (embedding tables, prediction or vision modules included); memory figures use this count
- Architecture
- Dense model, 64 layersHybrid: 16 full-attention layers (4 KV heads of 256), the other 48 are linear-attention (Gated DeltaNet) layers with a fixed-size state
- Context window
- 262,144 tokensAs set in the published configuration
- Published format
- BF16, 55.6 GB
- Licence
- Apache 2.0
- Released
- 21 April 2026
- Source
- Qwen/Qwen3.6-27Bconfig.json read 26 October 2026
Serve it with vLLM
template: vLLMOn 1× A30, from the instance terminal:
$ vllm serve Qwen/Qwen3.6-27B \ --tensor-parallel-size 1 \ --max-model-len 32768
Very recent architectures need a recent vLLM; the model card gives the minimum version and any extra flags.
Qwen3.6 27B on a GPU — the questions that come up
How much VRAM does Qwen3.6 27B need?
For the weights alone: 55.6 GB at BF16, 27.8 GB at FP8 and 13.9 GB at 4-bit. Add 2.15 GB of KV cache for one 32K-token context, or 17.2 GB at the full 256K window, and keep about 10% of the memory free for activations.
Can Qwen3.6 27B run on a single GPU?
One RTX 4090 (24 GB): yes, at 4-bit. One RTX 5090 (32 GB): yes, at 4-bit. One H100 SXM (80 GB): yes, at BF16. One H200 SXM (141 GB): yes, at BF16. One B200 SXM (180 GB): yes, at BF16. Those answers assume a 32K context and the widest format that still fits.
What is the cheapest way to run Qwen3.6 27B?
Here, 1× A30 at 4-bit: $0.05 per hour on spot and $0.08 on-demand, billed per minute — $36.50 for a 730-hour month on spot. That node has 24 GB of GPU memory for the 16.0 GB this setup needs.
How long a context fits on the recommended node?
With the weights at 4-bit on 1× A30, the remaining memory holds a 16-bit KV cache for about 117,645 tokens of context for one sequence (115K). An 8-bit KV cache doubles that; serving several users at once divides it between them.
Which format should I run it in?
BF16 keeps the published weights untouched and is the format for fine-tuning. FP8 halves the memory and runs in hardware on Hopper, Ada, Blackwell and MI300-class GPUs. 4-bit quantisation (AWQ, GPTQ, GGUF) quarters it, at a quality cost that is larger on small models than on big ones; check it against your own evaluation before relying on it.
How do I deploy it?
Pick the node in the table above and launch it with the vLLM template; the model downloads from Hugging Face (Qwen/Qwen3.6-27B) on first start. Spread the weights over the node with --tensor-parallel-size equal to the GPU count, and set --max-model-len to the context you need. New architectures need a recent vLLM: check the model card for the minimum version.
Sizing another model? GPU requirements for 64 open models · serving a language model · fine-tuning.
Qwen3.6 27B on 1× A30 for $0.05 an hour.
Launch the node with the vLLM template, point it at Qwen/Qwen3.6-27B, stop it when you are done. Prepaid, billed by the minute.
Billed per minute from the moment the instance is reachable. Minimum credit $30, no subscription.