CanItRun Logocanitrun.

Qwen 3.8 27B

Qwen 3.8 27B needs roughly 19.0 GB VRAM at Q4_K_M quantization (61.1 GB at FP16). 78 GPUs we track can run it fully in VRAM at 8k context.

78 GPUs run this natively · 21 with CPU offload

Alibaba27B params256k contextApache 2.0Commercial use ok
Q4_K_M total
19.0 GB
at 8k context
Smallest GPU
24 GB
NVIDIA RTX 4090, at Q4_K_M
KV cache, full context
17.2 GB
16 of 64 layers cache
Inputs
Text · Image · Video
Apache 2.0, released August 2026
Context ceiling
~1M tokens
262k native, YaRN extension
Vision
Native
same as Qwen 3.6 27B; GGUF still needs mmproj

Qwen 3.8 27B is a 27B parameter dense model developed by Alibaba. Released 14 August 2026 under Apache 2.0, the direct successor to Qwen 3.6 27B. The hybrid dense stack is unchanged layer-for-layer: 64 layers built from sixteen repeats of three Gated DeltaNet layers followed by one Gated Attention layer, so only 16 of the 64 layers keep a growing KV cache. Context is 262,144 tokens natively and roughly 1M with YaRN scaling, and the checkpoint accepts text, image, and video input, same as its predecessor.

To run Qwen 3.8 27B locally: Because the underlying shape didn't change from Qwen 3.6 27B, neither did the VRAM math: a Q4_K_M GGUF is roughly 16.4GB of weights, about 19GB in total at 8k context, making a 24GB card (RTX 4090, RTX 3090, RTX 5090) the comfortable target, with 16GB cards limited to Q3_K_M or partial CPU offload. The full 262k context window costs about 17GB of KV cache thanks to the hybrid stack. Vision needs the separate mmproj file, and there's no Ollama tag at launch, so llama.cpp, vLLM, or SGLang are the dependable routes until that lands.

Qwen's own model card reports GPQA Diamond 89.2, LiveCodeBench v6 90.3, SWE-bench Pro 61.7, and Terminal-Bench 2.1 73.0 — ahead of Qwen 3.6 27B on every one of those shared metrics, with the largest gains on agentic coding (SWE-bench Pro and Terminal-Bench). These are Alibaba's own launch figures; independent third-party reproduction was still thin in the first days after release.

The same hybrid stack as Qwen 3.6 27B, unchanged

Qwen 3.8 27B is dense, so all 27 billion parameters run on every token. Its 64 layers repeat the identical block Qwen 3.6 27B introduced: three Gated DeltaNet layers, then one Gated Attention layer, sixteen times over. Nothing about the caching shape moved between generations — what changed this release is what the model was trained on, not how its layers are wired.

Gated DeltaNetlinear attention, fixed-size stateGated Attention4 KV heads × 256 dim
layer 13:1 pattern × 16layer 64

16 of 64 layers keep a KV cache that grows with the full context. The other 48 hold a fixed-size recurrent state, so their memory cost does not move as the context window grows.

DeltaNet's memory is a fixed-size state matrix that costs the same at 2,000 tokens or 262,144, so those 48 layers add nothing to the KV bill regardless of context length. Only the 16 Gated Attention layers store per-token keys and values — the same one-in-four ratio that made Qwen 3.6 27B's long-context footprint small, carried forward unchanged into this release.

What a full 262,144-token context actually costs

Because the layer shape is identical to Qwen 3.6 27B's, the KV-cache math is too: this is the same four-times reduction versus an all-attention design, just on a slightly heavier set of weights.

02040608032k64k128k192k256k17.2 GBQwen 3.8 27B68.7 GBall-attention 27B
Qwen 3.8 27B — 16 of 64 layers cacheThe same model if all 64 layers used full attention

KV cache only, at FP16. Weights and activation overhead sit on top of these figures.

Filling the whole 262,144-token window costs 17.2 GB of KV cache instead of 68.7 GB. Add 16.4 GB of Q4_K_M weights and the full-context total is 37.7 GB, which a 48 GB workstation card holds. The all-attention version of the same model would have wanted 95.4 GB and a datacenter GPU.

VRAM at each quantization

Qwen 3.8 27B natively supports a longer context window, but the table below is capped at 8k for comparability — its hybrid attention stack keeps KV cache growth well below linear.

QuantWeightsKV cacheTotal
FP32108.0 GB0.54 GB121.6 GB
BF1654.0 GB0.54 GB61.1 GB
FP1654.0 GB0.54 GB61.1 GB
Q8_028.7 GB0.54 GB32.8 GB
Q6_K22.2 GB0.54 GB25.4 GB
Q5_K_M19.2 GB0.54 GB22.1 GB
Q4_K_Mrec16.4 GB0.54 GB19.0 GB
Q3_K_M13.0 GB0.54 GB15.2 GB
Q2_K10.3 GB0.54 GB12.1 GB
NVFP4cuda13.5 GB0.54 GB15.7 GB

Shown at 8k context with FP16 KV cache. NVFP4 needs a CUDA GPU to run. Toggle TurboQuant in the calculator to view compressed KV cache numbers.

Quantization × context: where it fits

The table above holds context fixed at 8k. Add context as a second axis and the picture changes: pick the row you can download, then the column you actually need. Each cell is the total VRAM for that pairing, weights and KV cache and activation overhead included.

Total VRAM needed by quantization and context length, with the GPU class each figure requires.
Quant8k ctx32k ctx128k ctx256k ctx
Q8_032.8 GB48 GB card34.5 GB48 GB card41.8 GB48 GB card51.4 GB80 GB card
Q6_K25.4 GB32 GB card27.2 GB32 GB card34.5 GB48 GB card44.1 GB48 GB card
Q5_K_M22.1 GB24 GB card23.9 GB24 GB card31.1 GB32 GB card40.8 GB48 GB card
Q4_K_Mrec19.0 GB24 GB card20.8 GB24 GB card28.0 GB32 GB card37.7 GB48 GB card
Q3_K_M15.2 GB16 GB card16.9 GB24 GB card24.2 GB32 GB card33.8 GB48 GB card
Each cell shows the smallest card that holds it:Consumer GPUWorkstation GPUDatacenter GPU

Benchmarks

GPQA Diamond
89.2
LiveCodeBench
90.3
SWE-bench Pro
61.7
Terminal-Bench 2.1
73.0

How this generation moved on GPQA Diamond

89.2 puts Qwen 3.8 27B among the higher scorers this site tracks at its size, a real step up from Qwen 3.6 27B's 87.8 on the same benchmark four months earlier, though the gap here is the smallest of the shared-benchmark deltas between the two releases — most of this generation's gains landed on coding and agentic tasks rather than general science QA.

65809510B100B1T10TTotal parameters (log scale)Llama 3.3 70B InstructLlama 3.1 8B InstructQwen 2.5 72B InstructQwen 2.5 32B InstructQwen 2.5 14B InstructQwen 2.5 7B InstructQwen 2.5 Coder 32B InstructMistral Small 22BGemma 2 27B InstructGemma 2 9B InstructPhi-3.5 Mini InstructPhi-4-mini InstructDeepSeek R1 Distill Llama 70BDeepSeek R1 Distill Qwen 32BDeepSeek R1 Distill Llama 8BLlama 3.1 70B InstructLlama 3.1 405B InstructDeepSeek V3 671BDeepSeek R1 671BLlama 4 Maverick 400BMiniMax M1 456BGPT-OSS 120BGPT-OSS 20BGLM-4.6 355BGLM-4.7 358BGemma 4 31BGemma 4 26B (MoE)Qwen 3.5 9BQwen 3.5 35B-A3B (MoE)MiniMax M2.5 229BGLM-5 744BNemotron 3.5 Lightning 30B-A3BQwen 3.6 27BKimi K2.6GLM-5.1 754BDeepSeek V4 Pro 1.6TMistral Medium 3.5 128BGLM-5.2 753BNemotron 3 Ultra 550B-A55BStep 3.5 FlashMiMo V2.5 ProKimi K2.5InklingKimi K3DeepSeek V4 Flash 0731 284BQwen3.8 2.4T-A95BQwen 3.8 27BMuse Glimmer 30B
GPQA Diamond, as reported by each model's own publisher. Scaffolding and harness differ between vendors, so read the gaps as approximate rather than a ranking.

GPUs that run Qwen 3.8 27B natively (78)

Show 73 more
Plus 21 GPUs that run it with CPU offload (slower)

Notes

Built on the Qwen3.5 architectural foundation, same as the Qwen3.8-Max flagship. Thinking mode is on by default (disable per-request), reasoning depth is tunable via reasoning_effort (xhigh by default, medium, or low), and preserve_thinking carries reasoning context across turns, on by default. Against its direct predecessor Qwen3.6-27B, Qwen's own model card shows gains across the board: GPQA Diamond 89.2 vs 87.8, LiveCodeBench v6 90.3 vs 83.9, SWE-bench Pro 61.7 vs 53.5, and Terminal Bench 2.1 73.0 vs Qwen3.6-27B's 63.4 on the same 2.1 revision (Qwen3.6-27B's own published number was a 2.0-revision 59.3, not directly comparable to either 2.1 figure).

Hugging Face ↗Released 2026-08-14

Compare Qwen 3.8 27B with other models

How to run Qwen 3.8 27B locally

816244880160320

Q4_K_M needs 19.0 GB — fits a single high-end consumer GPU (24 GB).

llama.cpp or vLLM/SGLang (no official Ollama tag at launch)

./llama-server \
  -hf unsloth/Qwen3.8-27B-GGUF:UD-Q4_K_XL \
  -c 65536 -ngl 99 \
  --temp 1.0 --top-p 0.95 --top-k 20 --min-p 0.0

llama.cpp

# Non-thinking mode, for straight instruction following
./llama-server \
  -hf unsloth/Qwen3.8-27B-GGUF:UD-Q4_K_XL \
  -c 65536 -ngl 99 \
  --temp 0.7 --top-p 0.8 --top-k 20 --presence-penalty 1.5 \
  --chat-template-kwargs '{"enable_thinking":false}'

# Vision needs the projector file alongside the weights, same as Qwen 3.6 27B
./llama-server -hf unsloth/Qwen3.8-27B-GGUF:UD-Q4_K_XL \
  --mmproj mmproj-F16.gguf

LM Studio: Search for 'Qwen3.8 27B' and take the Q4_K_M or UD-Q4_K_XL build. Set the context slider deliberately: every 32k of context costs about 2.1 GB of KV cache, same ratio as Qwen 3.6 27B since the layer shape didn't change between releases.

Why this quantization? Q4_K_M puts the weights at roughly 16.4 GB, which leaves a 24 GB card enough room for around 56k of context, the exact same budget Qwen 3.6 27B offers at the same quant. Step up to Q5_K_M or Q6_K only if you have 32 GB or more.

Who is Qwen 3.8 27B for?

Developers with a single 24 GB GPU who want a coding agent that runs locally and holds a long repository context, and anyone upgrading from Qwen 3.6 27B who wants the same VRAM footprint with better coding/agentic scores and native vision.

Best for

  • Agentic coding loops where the model reads a repo, edits files, and runs commands
  • Long-context work: whole-file refactors, log analysis, multi-document review
  • Multi-turn sessions that benefit from preserved reasoning traces between turns
  • Image and video understanding via the vision projector
  • Replacing a paid coding API on a single workstation

Not ideal for

  • 16 GB GPUs, where you are forced down to Q3_K_M or partial CPU offload
  • Ollama users, at least until an official tag ships — there is none at launch
  • Latency-sensitive chat, since thinking mode is on by default and adds tokens before every answer
  • Anyone who needs benchmark claims independently verified before adopting a model this new

So should you run it?

If Qwen 3.6 27B already fit your GPU, Qwen 3.8 27B fits it too — the KV-cache math and the weights size are both identical. On a 24 GB card that's still the easy local-agentic-coding pick, with real gains on coding and agentic benchmarks. The one thing to check first is Ollama support: there's no official tag yet at launch, so llama.cpp, vLLM, or SGLang are the dependable route until that lands, same as it was for Qwen 3.6 27B on day one.

Explore

Browse all guides →Browse all models →Browse all GPUs →

Frequently asked questions

What are the VRAM requirements for Qwen 3.8 27B?
Qwen 3.8 27B requires approximately 19.0 GB of VRAM at Q4_K_M quantization, 32.8 GB at Q8, and 61.1 GB at FP16. These numbers assume 8k context window; its hybrid attention stack caches far fewer than all layers, so VRAM grows much slower than linearly with context.
How many parameters does Qwen 3.8 27B have?
Qwen 3.8 27B has 27 billion parameters.
Is Qwen 3.8 27B good for coding?
Yes. Qwen 3.8 27B scores 90.3 on LiveCodeBench, demonstrating strong code generation and completion capabilities.
Can Qwen 3.8 27B run on a 16 GB GPU?
No. At Q4_K_M, Qwen 3.8 27B needs 19.0 GB of VRAM — more than 16 GB. You will need a 24 GB GPU like the RTX 4090 or RTX 3090.
Can Qwen 3.8 27B run on a 24 GB GPU?
Yes. Qwen 3.8 27B fits in a 24 GB GPU at Q4_K_M, requiring 19.0 GB VRAM. GPUs with 24 GB include the RTX 4090, RTX 3090, and RTX 3090 Ti.
What is the smallest quantization for Qwen 3.8 27B that fits in 24 GB of VRAM?
At NVFP4, Qwen 3.8 27B needs 15.7 GB — the highest-quality quantization that fits in 24 GB of VRAM.
What GPU do I need to run Qwen 3.8 27B locally?
A 24 GB GPU is the minimum. At Q4_K_M, Qwen 3.8 27B needs 19.0 GB VRAM. Good options: RTX 4090 (24 GB), RTX 3090 (24 GB).
How is Qwen 3.8 27B different from Qwen 3.6 27B?
Architecturally, nothing changed: both use the identical 64-layer hybrid stack (16 Gated Attention layers, 48 Gated DeltaNet layers) and the same real parameter count, so their KV-cache size and weights size at any quant or context length are the same. What changed is training — Qwen 3.8 27B scores higher on every benchmark Qwen reports for both (GPQA Diamond, LiveCodeBench, SWE-bench Pro, Terminal-Bench 2.1).
Does Qwen 3.8 27B need a separate file for vision input?
Its upstream Transformers checkpoint has the vision encoder built in, same as Qwen 3.6 27B's own checkpoint. For local use with llama.cpp, both still ship as a separate mmproj GGUF alongside the main weights — that's a llama.cpp packaging convention for every vision-capable GGUF, not something specific to either release.
Is Qwen 3.8 27B available on Ollama?
Not at launch — there's no official Ollama tag yet, mirroring the rough patch Qwen 3.6 27B's own day-one GGUFs hit. llama.cpp, vLLM, and SGLang are the dependable options until that changes.