Qwen3.8-27B VRAM: 11GB to 56GB by Quant Level

Qwen3.8-27B VRAM by quantization level

The 27B weights do not ship in one size. Quantization, which stores each weight with fewer bits, is what decides whether the model lands on a consumer card at all.

Run Qwen3.8-27B locally: the 4-bit build fits a 24GB card

Unsloth puts the 4-bit build at 17-19GB and names the cards it lands on: an RTX 5080, a 4090, or a Mac with 24GB of RAM. That range is the practical target for anyone running the model on hardware they already own.

Two details in the table are easy to miss. The unit is total memory rather than VRAM alone, so a Mac's unified memory counts the same way a discrete card does. And a 16GB GPU is short even at 4-bit, which pushes it down to 3-bit or 2-bit where the quality drop starts to show in longer outputs.

Context length is billed on top of the weights

The memory table covers the weights only. Every token in the context window occupies a KV cache, the store of past tokens the model keeps while it generates, and that cache lives beside the weights rather than inside them.

This matters because the native window is 262,144 tokens. A 4-bit build that fits in 19GB does not stay at 19GB once a long document is loaded, so a 24GB card that looks comfortable on paper can run out at full context. Sizing from the quant table alone is the most common way to be surprised.

The million-token figure is a ceiling, not a default

The 1M number that travels with this release is the extended ceiling, not what the downloaded weights do out of the box. Reaching it means applying YaRN, a technique that stretches positional information to buy a longer window, and paying for the additional KV cache that comes with it.

Qwen also lists a 1M context window as a feature of the hosted version rather than of the local weights. Anyone planning capacity around a million tokens on their own hardware is planning around the wrong number.

What the hardware actually buys

Fitting the model on a card is one question. What the model is licensed and built to do is another, and it is where a 27B open-weight release earns its place over an API.

Apache 2.0 removes the legal step

The weights are licensed under Apache 2.0, which allows modification, redistribution and commercial use without a separate agreement. Embedding it in an internal system, shipping it inside a product, or publishing a fine-tuned derivative are all covered.

One distinction is worth keeping straight: open weight is not open source. Qwen publishes the weights, not the training data or the full recipe, so the model cannot be reproduced from scratch. For deployment that changes nothing, but for anyone auditing provenance it changes a great deal.

Images and video are native inputs

Qwen3.8-27B reads images and video directly rather than through a separate captioning step. Qwen describes the coverage as running from STEM diagrams and documents up to hour-scale video.

For a self-hosted deployment that removes a whole component. Document work that would otherwise need an OCR stage, a layout parser and a language model can be handed to one set of weights, which is a meaningful saving when the point of running locally was to keep the stack small.

The official FP8 build is not a consumer-GPU option

Qwen ships its own FP8 quantization, and the model card says its scores are nearly identical to the original. FP8 stores each number in eight bits, applied here at a block size of 128.

Quality-wise that is the safest reduction on offer, because the people who trained the model produced it. Size-wise it is out of reach for a single consumer card: the 8-bit row in the table is already 31GB. On hardware you own, the realistic landing point remains a community-made GGUF build around 4-bit. GGUF is the quantized file format that llama.cpp-based tools read.

Before you buy hardware for it

Two things are worth checking before a benchmark score turns into a purchase order.

The benchmark table is not measured under matched conditions

Qwen's own footnote says the comparison models were re-measured rather than quoted. Only one competitor's score is the officially reported one; the rest were run by Qwen through the Claude Code harness at a fixed temperature and context window.

Re-measuring is not misconduct, and stating it is the honest thing to do. It does mean that small gaps between vendors in that table carry less information than they appear to, because part of the difference is the harness rather than the model.

Serving engine and sampling settings change the result

Loading the weights is not the same as running them well. Qwen recommends dedicated serving engines for production throughput, and publishes different sampling settings for thinking and non-thinking modes.

Getting these wrong is a common reason a local build feels worse than the hosted demo. The thinking mode expects temperature 1.0 with top_p 0.95; the instruct mode expects temperature 0.7 with top_p 0.80. Leaving a client's defaults in place quietly evaluates a different configuration from the one the scores describe.

The model card that holds all of these numbers is built from tables and nested bullet lists, and copying it into a chat window flattens exactly the structure the numbers live in. Converting the page to markdown first keeps the headings and tables intact, so nothing is silently dropped when a model reads it back.

Free ToolURL to Markdown ConverterConvert any public web page URL to Markdown. Preserves headings, tables, lists, and links — perfect for LLM and RAG preprocessing, research notes, and archiving web articles.Try it now →

Qwen3.8-27B is a rare combination: a size that fits on hardware people already own, under a license that asks nothing in return. The honest constraint is memory. Pick the quantization level your card can hold, leave room for the context you actually use, and test it on your own workload before deciding — the published scores were measured on someone else's setup, and the memory table is the part that applies directly to yours.