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

Qwen3.8-27B VRAM: total memory by quantization level

Alibaba's Qwen team does not ship the 27B weights (27 billion parameters) in a single size. Quantization means storing each weight in fewer bits, and it decides whether the model fits on a consumer card at all.

Total memory by quantization level

Quantization	Memory required
1-bit	7-8GB
2-bit	9-11GB
3-bit	12-14GB
4-bit	16-19GB
6-bit	23-26GB
8-bit	31GB
BF16 (uncompressed)	56GB

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

Unsloth, which packages open models into smaller downloadable builds, puts the 4-bit build at 16-19GB and lists the hardware that runs it: an RTX 5080, an RTX 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 “Total memory by quantization level” are easy to miss. The figures are total memory, not VRAM alone (VRAM is what sits on the graphics card itself), so a Mac's unified memory counts the same. And 16GB sits right at the bottom of the 4-bit range, so a 16GB card is a borderline fit rather than a safe one — dropping to 3-bit buys headroom at some cost to output quality.

These numbers have already changed once. On August 19, Unsloth's table started at 2-bit — no 1-bit row — and put 4-bit at 17-19GB.

That same day Unsloth switched to a new build process it calls Dynamic V3.0, and now claims about 10% more accuracy at the same file size. Check the vendor table before you buy hardware. Numbers republished elsewhere go stale.

Context length costs memory on top of the weights

The memory table covers only the weights. The context window is how much text a model can keep in front of it at once, measured in tokens (the chunks of words and punctuation that models read and write).

Every token takes up room in the key-value cache, or KV cache — the running store of what the model has already read and written. 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 of memory once the context is full. Sizing your hardware from the quantization table alone is an easy way to get caught short.

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

The downloaded weights do not give you a million tokens out of the box. Reaching that number means turning on YaRN, a technique that stretches the model's sense of position in the text so it can handle a longer document. You pay for it in memory, too: the longer window needs a bigger KV cache.

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

What you get once it fits

Fitting the model on a card is one question. What the model is licensed and built to do is another, and that is where a 27B open-weight model beats renting someone else's API.

Apache 2.0 means you can ship what you build

The weights are licensed under Apache 2.0, so you can modify them, pass them on, or sell what you build with them, with no separate agreement. Embed them in an internal system, ship them inside a product, or retrain them on your own data and publish the result. All of that is covered.

One distinction still applies: open weights are not the same as open source. Qwen publishes the weights, not the training data or the full recipe, so the model cannot be reproduced from scratch.

That makes no difference when you deploy it. It does matter if you ever need to show where a model came from.

Images and video are native inputs

Qwen3.8-27B reads images and video directly rather than through a separate captioning step. Qwen says that covers science and engineering diagrams and documents, along with video up to an hour long.

If you host it yourself, that collapses a whole pipeline into one model. Doing the same thing with documents would otherwise take three separate tools: optical character recognition to pull the text off the page, a parser to figure out the layout, and a language model to make sense of what is there.

One set of weights does all three. That matters if the whole point of running locally is to keep the stack small.

The official FP8 build comes from Qwen itself

Qwen ships its own FP8 build, and the model card — the spec sheet published with the weights — says that build scores almost the same as the original. FP8 stores each weight in eight bits, and Qwen quantizes 128 weights at a time.

On quality, it is the safest step down: the people who trained the model made this build too. On size, it is out of reach for a single consumer card. Qwen publishes no memory figure for the FP8 build, but FP8 is an 8-bit format, and Unsloth's 8-bit row already reads 31GB.

On hardware you own, what you will actually run is a community-made 4-bit build in a file format called GGUF — the format nearly every free tool for running models locally can read. That is the setup behind Local LLM Coding Now Hits 75% of Cloud AI.

The model card, the FP8 card, and the Unsloth page each hold a different part of the sizing picture, and none of them repeats what the others have. Pulling all three into markdown puts the tables side by side.

Scores, price, and settings to check first

A benchmark score on its own says nothing about how it was measured, what the tokens cost, or which settings the model ships with. Check all three before the score turns into a hardware purchase.

The benchmark scores were not all measured the same way

In a footnote, Qwen says it re-ran the comparison models itself rather than quoting their published scores. Only Opus 4.6 Max keeps its officially reported number. Qwen generated the rest, running every other model through one Claude Code setup at the same settings and context window.

Re-running rivals is not misconduct, and saying so in a footnote is the honest thing to do. It does mean that small gaps between vendors in those scores matter less than they look. Part of the difference belongs to the test rig, not to the model.

The Artificial Analysis Intelligence Index puts Qwen3.8-27B first

Vendor tables cannot tell you how a model stacks up against everything else. Independent measurement can. Artificial Analysis, which runs its own tests instead of repeating vendor numbers, scores Qwen3.8-27B at 41 on its Intelligence Index — first among the 140 open-weight models in the 4B-40B class, against a class median of 4.

Frontier models (the biggest systems there are, the kind you rent access to in someone else's data center) still rank above it on the same index. The class ranking is the narrower claim, and the more useful one: among open-weight models between 4B and 40B parameters, the page shows nothing scoring higher.

The reasoning setting in parentheses is part of what was scored. The entry measured here is the xhigh variant, and the page notes that a non-reasoning variant may also exist, so two entries carrying the same model name are not interchangeable.

The rows people skip are price, verbosity, and speed. Artificial Analysis calls the model particularly expensive next to open-weight models of similar size and adds that it is notably slow and somewhat verbose, with roughly 1.2 times the median token count to run the Index. Running the full Index against it cost Artificial Analysis $900.36.

Rent access through an API and all three costs stack up. Since the weights are public, the alternative is running it on a graphics card you own.

None of this holds still, and the scale itself moves. The index is now on version 4.2, and in late August the same entry carried a higher score against a smaller comparison class. Price your own workload from the live page, not from a figure quoted in an article.

Serving engines and sampling settings change the result

Loading the weights is not the same as running them well. Qwen recommends purpose-built serving software for anyone running the model at volume. It also publishes different sampling settings for its two modes: thinking, where the model reasons step by step before answering, and non-thinking, where it answers straight away.

Getting these wrong is a common reason a local build feels worse than the hosted demo. Thinking mode expects temperature 1.0 with top_p 0.95; non-thinking mode drops to 0.7 and 0.80. Both settings control how much randomness goes into picking each next token.

Leave your chat app's defaults in place and you are quietly running a different configuration from the one those scores came from. The model card behind these numbers is built out of tables and nested bullet lists, and copying it into a chat window flattens exactly the structure that makes the numbers readable. Converting the page to markdown first keeps the headings and tables intact, so nothing is silently dropped when a model reads it.

What a 27B model did on a real task

Benchmarks measure a model against a fixed set of tests. A week after the weights landed, someone measured it against a job.

Thirty minutes on a job that was supposed to need a frontier model

Adam Conway of XDA Developers handed Qwen3.8-27B a job he had assumed needed a frontier model: figuring out how a commercial application's licensing worked. It finished in about 30 minutes.

By Conway's account, doing it by hand would have taken far longer. The model never ran the application — it worked from the files alone.

The run happened on a compact workstation built around Nvidia's GB10 Grace Blackwell chip: 128GB of unified memory and 273GB/s of bandwidth. Compare that with the memory table above. A 24GB gaming card is nowhere near it, so treat these speeds as an upper bound.

Out of the box, the model ran at 15 to 30 tokens per second. Three changes got it to roughly 50 tokens per second on coding and reasoning tasks: the SGLang serving engine, a more compact number format called NVFP4, and speculative decoding. In speculative decoding, a small model drafts text for the big one to check.

Conway calls that combination the standard recipe for this hardware. It is the serving advice from earlier, with numbers attached.

The model caught the jailbreak, then caught its own mistake

The model's handling of the request mattered more than its speed. The request arrived wrapped in a jailbreak (a prompt written to talk a model out of its own rules), with Conway posing as the application's developer.

The model spotted the pattern and said up front that it would not fall for it. From there it checked the application's code-signing certificate, pointed out that the person asking had not built the application, and named the real developer.

Then it made an error and fixed it. Its first reconstruction of the licensing scheme was wrong; with no correction from Conway, the model caught the mistake itself and reached the right answer.

Verbosity showed up here just as it did in Artificial Analysis's measurements. Reasoning effort defaults to maximum, so even trivial requests burn hundreds or thousands of tokens, and at 30 to 50 tokens per second the wait adds up. Turn reasoning_effort down for anything routine.

How far this generalizes, and how far it does not

Conway ran it once, on one application. Conway says outright that the next program might stump it.

Conway reads the result as a threshold: work that used to need a frontier model can now be done on a machine you own. He puts the model at 17GB of VRAM — the same bracket as the 4-bit build in “Total memory by quantization level” above.

What this data point supports, and what it does not

Supported	Not supported
A 27B model finished a multi-stage analysis task	A success rate on comparable tasks
It corrected its own error unprompted	Generalization to other programs or domains
Maximum reasoning effort by default made routine work slow and verbose in this run	A recommended speed-versus-quality setting
It reached roughly 50 tokens per second on the recommended SGLang stack	Throughput on a single consumer graphics card

Conway ends on the point that matters for adoption: change who is at the keyboard, and the same properties that make local models appealing turn into a security problem. He is explicit that this is not an argument against local models. The practical step is to decide who runs them, and on what, before anything gets deployed.

Summary: Qwen3.8-27B fits a 24GB card, and memory is the limit

Qwen3.8-27B fits on hardware people already own, and its license asks nothing in return. The real constraint is memory. Pick a build that fits your card with room left over for the context you will actually use.

Then test it on your own workload before you commit. The published scores were measured on someone else's setup. The memory table is the one part that carries over to your machine unchanged.