Qwen3.8 27B Requirements: VRAM, GPU & RAM (2026)

Qwen3.8-27B needs roughly 9GB to 56GB of VRAM depending on the quantization format. The weights landed on Hugging Face on August 15, 2026 (JST), which means the actual published file sizes are now known. This requirements guide is built on those measured sizes rather than estimates.

The most consequential detail first: Q4_K_M, the usual go-to for personal use, is 17.1GB and will not fit on a 16GB GPU. The prior-generation Qwen3.6-27B's Q4_K_M measured 16.8GB, so this is a small but decisive increase. On 16GB hardware you'll need IQ4_XS (15.7GB) or UD-Q3_K_XL (13.4GB) instead.

On August 3, 2026, Alibaba announced Qwen3.8-Max, a 2.4T-parameter MoE model (95B activated parameters, 1M context length, API pricing of $2/$6 per million input/output tokens). We cover it in detail in What Is Qwen3.8 Max. Alongside that announcement, Alibaba previewed a smaller, self-hostable model — Qwen3.8-27B — which shipped on Hugging Face on August 15 (JST).

Two repositories went live: a BF16 safetensors release (Qwen/Qwen3.8-27B) and an FP8 release (Qwen/Qwen3.8-27B-FP8). The license is Apache-2.0, permitting redistribution, commercial use, and fine-tuning with no monthly-active-user caps or similar riders attached. For a company evaluating this for internal systems, the license review is effectively a single check.

The config.json declares Qwen3_5ForConditionalGeneration (model_type qwen3_5), confirming this is dense, not MoE. It has 64 layers, a hidden size of 5,120, GQA with 24 attention heads against 4 KV heads, and a 248,320-token vocabulary. Attention is hybrid: Gated DeltaNet linear attention alternates with full attention every four layers. Because only a quarter of the layers carry full attention, KV cache consumption at long context should be lower than a conventional dense model of comparable size.

The substantive change from the prior generation is that this is a native vision-language model with a built-in vision encoder — depth 27, hidden 1,152, patch size 16, projecting into the language model's 5,120 dimensions, with dedicated token IDs for image and video input. If you plan to feed images or video through a GGUF build, note that you need a separate mmproj (multimodal projector) file on top of the quantized weights.

The sizes below come from the official repositories and Unsloth's GGUF repository. The VRAM column is a practical recommendation — the weights themselves plus headroom for KV cache and activations. Longer contexts require more.

The GGUF figures are from Unsloth's Dynamic V3.0 (preview) builds. Identical quantization names can differ by hundreds of megabytes between publishers, so if you're targeting a tight ~16GB fit, check the actual file size in the specific repository before downloading.

Picking a quantization format is a trade-off between available VRAM and desired quality. Our guide to Qwen3.5 27B/35B local deployment covers the same decision framework for a similarly sized dense model and is worth reading alongside this one.

- BF16: Best for workstations and servers with ample VRAM — no quality loss
- FP8: A good speed/quality balance on FP8-capable GPUs
- Q8_0 / UD-Q6_K_XL: Prioritize quality while trimming file size somewhat
- Q4_K_M / UD-Q4_K_XL: First choice on a 24GB GPU
- IQ4_XS / UD-Q3_K_XL: The practical tier on 16GB, since Q4_K_M won't fit
- UD-IQ2 family: For severely VRAM-constrained setups, only if you can tolerate degraded output

The table below reflects the published file sizes. Measured tokens/sec data is still thin this soon after release, so this table is limited to what fits.

One caveat worth stating plainly: BF16's 55.6GB will not fit a single A6000 48GB. Running full precision means an 80GB-class card or splitting across multiple GPUs. On 48GB, FP8 (~25GB) is the effective ceiling.

Apple Silicon shares unified memory between CPU and GPU, so the Mac's total memory is the effective VRAM ceiling. Based on actual file sizes:

- 16GB unified memory: The UD-IQ2 builds (9–11GB) will load, but they compete with the OS and other apps and quality is significantly degraded
- 24GB unified memory: IQ4_XS (15.7GB) or UD-Q3_K_XL (13.4GB) is the realistic pick; Q4_K_M is reachable if you close other apps
- 32GB unified memory: Q4_K_M (17.1GB) through Q5_K_M (19.8GB) run practically
- 48GB unified memory: Q8_0 (29GB) and FP8 (~25GB) come into view
- 64GB unified memory: Q8_0 with comfortable headroom, including longer contexts
- 128GB unified memory: Full BF16 (55.6GB) operation is realistic

If you're using image or video input, budget an extra 931MB for the mmproj file on top of the figures above.

Without a GPU, CPU inference works with a 4-bit-or-smaller GGUF. But 27B-class dense models rarely reach practical interactive speeds on CPU alone. Plan for roughly 16GB of system RAM for IQ4_XS or 24GB for Q4_K_M, and treat it as suited to batch processing rather than chat. Note too that thinking mode is on by default, so the model generates reasoning tokens before responding — on CPU, consider lowering reasoning_effort.

The official model card ships serving instructions for vLLM, SGLang, and Docker, all usable from day one. Unsloth published Dynamic V3.0 (preview) GGUF builds on release day, so llama.cpp and LM Studio can load the model directly from Hugging Face.

However, the official Ollama library had no qwen3.8 entry as of 00:00 JST on August 15, 2026, so ollama run qwen3.8:27b does not yet work. Based on the prior generation's pattern it should appear within hours to days; until then, point your setup at the GGUF file directly. For choosing among local inference engines generally, see our local LLM inference engine comparison.

The prior-generation Qwen3.6 27B dense coding model, released in April 2026, was a dense model with hybrid text/image/video multimodal input and a 262,144-token context length. Qwen3.8-27B keeps both the dense architecture and the 262,144-token native context, adding YaRN extension to 1M tokens, the Gated DeltaNet hybrid attention scheme, and thinking mode enabled by default.

The benchmark figures below are from the official model card, and the gains are concentrated in coding and agentic tasks.

The model card reports these scores as beating the larger Qwen3.7-Plus across every listed benchmark. These are vendor-reported numbers and still warrant validation against your own workload — but for a 27B-class model that fits on hardware you already own, it's a strong starting position.

The license is Apache-2.0. Commercial use, modification, and redistribution are all permitted, with no monthly-active-user ceiling or use-case carve-outs attached. Embedding it in internal systems, shipping it inside a commercial product, and distributing fine-tuned derivatives are all allowed provided you meet Apache-2.0's standard conditions — retaining the copyright notice and including the license text.

With licensing effectively a non-issue, the evaluation narrows to two questions: does it fit your GPU, and does it meet your accuracy requirements on your own data. The first is answered by the table above; the second still requires testing against real workloads.

- Q4_K_M OOMs on a 16GB GPU: Working as expected — it's 17.1GB. Switch to IQ4_XS (15.7GB) or UD-Q3_K_XL (13.4GB)
- It should fit by file size but still OOMs: Check that you've budgeted headroom for the KV cache; shortening the context length usually resolves it
- Image input throws an error: With GGUF you must download the mmproj file (931MB) separately and point your inference engine at it
- Extremely slow with CPU offloading: Revisit partial-offload settings and maximize the layers that fit on the GPU
- Long delay before the response starts: Thinking mode is on by default; lowering reasoning_effort shortens it
- Swapping on Apple Silicon: Close other apps to free unified memory, or drop one quantization tier