Qwen 3.8 Local Requirements: VRAM, File Sizes and Hardware for 27B and Flash-Next

Qwen 3.8 local requirements depend on which model you mean. Qwen3.8-27B is dense, and its 4-bit GGUF files of 14.3 to 19.0 GB run on one 24 GB GPU with roughly 38,000 to 110,000 tokens of context, or on a 32 GB RTX 5090 with about 148,000. Qwen3.8-Flash-Next activates 6 billion of its 180 billion stored parameters and needs about 94 to 120 GB at 4-bit, which suits a 128 GB DGX Spark or Mac, while the 2.4-trillion-parameter model behind Qwen3.8-Max needs a GPU cluster.

Qwen published the Qwen3.8 open weights in August 2026: the 2.4-trillion-parameter flagship on 12 August, the dense 27B on 14 August and Flash-Next on 26 August. A Qwen 3.8 9B or 35B does not exist officially, and Qwen 3.8 Max is downloadable only under another name.

This guide covers what Qwen released, the community builds made from it and the memory each file needs, checked on 4 November 2026 with the method of our LLM VRAM calculator.

Qwen 3.8 models at a glance

All three think by default and accept a reasoning_effort of low, medium or xhigh; only the 2.4T model cannot switch thinking off.

Flash-Next is the unusual one: Qwen presents it as an early, experimental look at the design Qwen4 will use. Its sparse attention selects context in small blocks, and its n-gram embedding, a 20-million-row table looked up by bigrams and trigrams, adds 51 billion parameters at almost no compute cost. That table can sit in host memory, which shapes the tiers below.

Three names in search results are hosted models. Qwen3.8-Flash is Qwen Cloud’s production version of Flash-Next, with a 1M-token window and built-in tools, and Qwen3.8-Omni-Flash adds audio input; both cost $0.15 per million input and $0.47 per million output tokens as of 4 November 2026. Qwen3.8-Max is the hosted form of the open 2.4T model, adding image input and a non-thinking mode.

Is there a Qwen 3.8 9B or 35B?

No. Qwen’s Hugging Face organisation holds six Qwen3.8 repositories, the three models above in BF16 and FP8. Files named Qwen3.8-35B-A3B or Qwen3.8 9B are third-party distillations; Empero’s 35B-A3B uses the older Qwen3.6-35B-A3B architecture. For 8 to 16 GB cards, our model picks for each VRAM size cover the official alternatives.

Qwen 3.8 27B size: every build you can download

Repository totals on 4 November 2026; only the first two rows come from Qwen.

One label can mean different sizes: Q4_K_M is 16.8 GB from LM Studio’s community account, 17.4 GB from bartowski and 19.0 GB from ggml-org. The vision encoder ships as a separate 0.6 to 0.9 GB mmproj file. NVFP4 builds need a Blackwell GPU, such as an RTX 50-series card or a DGX Spark, Unsloth notes; on an RTX 4090, use GGUF.

Qwen 3.8 Flash Next size and builds

Flash-Next stores 180 billion parameters but computes with 6 billion. Unsloth keeps the n-gram table at 4 bits or more, because squeezing it harder damages the model, so even its 1-bit file weighs 72.6 GB.

Unsloth measured top-1 token agreement with the full model at 77.3% for UD-IQ1_S, 89.6% for UD-IQ4_XS, 92.3% for UD-Q4_K_XL and 94.1% for Q8_0. NVIDIA’s NVFP4 build quantizes only the routed experts to 4 bits and lists B200 and B300 as its test hardware.

How to estimate Qwen 3.8 VRAM requirements

Memory is the weights (parameters × bits ÷ 8, or the file size above), plus the KV cache for the context you keep, plus runtime overhead.

Qwen3.8-27B caches only 16 of its 64 layers, each with 4 key-value heads of 256 dimensions: 2 × 16 × 4 × 256 × 2 bytes, or 64 KiB per token at 16-bit. That is 8.6 GB for 131,072 tokens and 17.2 GB for the full window, halved by an 8-bit cache, plus a fixed 0.15 GB of DeltaNet state per conversation. Flash-Next’s 12 sparse-attention layers hold 2 key-value heads each, so a token costs 24 KiB: 6.4 GB for the native window, plus a small indexer cache.

Like the calculator, the tables count 90% of GPU memory and 80% of unified memory as usable, for one conversation.

Qwen 3.8 VRAM requirements by tier

Qwen3.8-27B

The 32 GB tier is the comfortable one, on NVIDIA or AMD’s Radeon AI PRO R9700; our GPU buying guide for local models compares the cards.

Qwen3.8-Flash-Next

Bandwidth then sets speed. Our tokens-per-second calculator divides 60% of peak bandwidth by the bytes read per token: about 17 GB for the 27B at Q4_K_M, giving ceilings near 63 tokens per second on an RTX 5090’s 1,792 GB/s, 22 on a 614 GB/s M5 Max and under 10 on a 273 GB/s DGX Spark. Flash-Next reads about 3.7 GB at 4-bit, lifting the Spark’s ceiling to about 45. These are upper bounds, not benchmarks.

Running Qwen 3.8 locally: Ollama, LM Studio, llama.cpp, vLLM and SGLang

Desktop tools suit one person, vLLM and SGLang a shared server; see our vLLM, Ollama and llama.cpp comparison.

Ollama

ollama run qwen3.8 pulls the 27B at q4_K_M, 18 GB with image input, tools and thinking. Flash-Next needs a tag: qwen3.8-flash-next:125b-a6b-q4_K_M (120 GB), or qwen3.8-flash-next:125b-mlx (105 GB) for Ollama’s MLX engine on Apple silicon. Neither had a cloud tag on 4 November 2026. The default context runs from 4K tokens below 24 GiB of VRAM to 256K from 48 GiB up; Ollama suggests at least 64,000 for agents:

OLLAMA_CONTEXT_LENGTH=65536 ollama serve

LM Studio

The catalogue lists qwen/qwen3.8-27b with a 16 GB minimum, as GGUF and as MLX 4- to 8-bit builds, and qwen/qwen3.8-flash-next as GGUF with a 96 GB minimum. Unsloth’s own app runs the UD files; our Unsloth Studio and LM Studio comparison explains how they differ.

llama.cpp

The 27B uses the Qwen3.5 architecture. Flash-Next support arrived on 27 August 2026 (pull request #27742) and its multi-token prediction on 1 October (#29761).

# 27B on a 24-32 GB GPU
llama serve -hf ggml-org/Qwen3.8-27B-GGUF:Q4_K_M -c 65536

# Flash-Next with routed experts in system RAM; drop --cpu-moe on a 128 GB machine
llama serve -hf unsloth/Qwen3.8-Flash-Next-GGUF:UD-IQ4_XS --cpu-moe -c 65536

Without -c, the default --fit option trims the model’s 262,144 tokens to the memory it finds. llama.cpp can also read huge per-layer embedding tables, such as the n-gram table, from the file on demand (--lazy-mode, automatic for tensors over 4 GiB), so real memory use can sit below the file size.

vLLM

The 27B recipe asks for vLLM 0.17.0 or newer, Flash-Next for 0.30.0 or newer; 0.32.0, released on 18 October, was current on 4 November. The single-GPU command:

vllm serve Qwen/Qwen3.8-27B \
  --tensor-parallel-size 1 \
  --enable-auto-tool-choice \
  --tool-call-parser qwen3_coder \
  --reasoning-parser qwen3 \
  --mm-encoder-tp-mode data

Use Qwen/Qwen3.8-27B-FP8 to halve the weights, --kv-cache-dtype fp8 to halve the cache and --speculative-config '{"method":"mtp","num_speculative_tokens":3}' for the built-in draft head. For Flash-Next, the recipe runs Inferact’s NVFP4 build on four RTX PRO 6000 cards with expert parallelism. On eight H100s, vLLM moves the n-gram table to host memory by default, which needs at least 51 GB of host RAM.

SGLang

Qwen’s repository gives a four-GPU example; SGLang’s cookbook also has single-GPU recipes for the 27B on an RTX 5090, RTX PRO 6000 and DGX Spark:

sglang serve --model-path Qwen/Qwen3.8-27B --port 8000 --tp-size 4 --context-length 262144 --reasoning-parser qwen3 --tool-call-parser qwen3_coder

Qwen 3.8 on an RTX 5090, a DGX Spark or a Mac

Qwen 3.8 27B on an RTX 5090

In llama.cpp the 19.0 GB Q4_K_M file leaves about 148,000 tokens of 16-bit cache on the 5090’s 32 GB, and a 22.0 GB 6-bit file about 102,000. vLLM is tighter: its recipe found 31.4 GiB usable, and an NVFP4 build starts only with CUDA graphs off (--enforce-eager) and a 32,768-token limit, leaving a 91,022-token cache pool. Two 5090s hold the full window. Flash-Next needs --cpu-moe and about 128 GB of system memory.

Qwen 3.8 Flash Next on a DGX Spark

Flash-Next is the Qwen3.8 model that suits a Spark. Unsloth’s 93.7 GB UD-IQ4_XS fits the 128 GB with room for the native window. SGLang’s cookbook measured another route: because the Spark’s memory is one pool, it writes the 47.7 GiB FP8 n-gram table to a file on the NVMe drive and keeps the other 78 GiB of an NVFP4 build resident. It recorded 27.5 tokens per second for one stream with multi-token prediction and 15.9 without; two Sparks linked at 200 Gb/s reached 47.4 with it. Each boot rewrites that file, which took 55 minutes when the old copy was left in place. The dense 27B runs on a Spark too, but our estimate caps it near 10 tokens per second.

Qwen 3.8 on a Mac

The Mac Studio comes with an M5 Max, up to 128 GB at 460 or 614 GB/s, or an M5 Ultra with 96, 256 or 512 GB at 1.2 TB/s. The 27B’s MLX builds fit 24 GB Macs at 4-bit and 48 GB Macs at 8-bit. Flash-Next wants 128 GB: Unsloth’s 93.7 GB file fits, while Ollama’s 105 GB MLX tag and the 111.5 GB mlx-community build pass our 80% line. DwarfStar, a small open-source engine, says its 2-bit Flash-Next build runs on 64 GB Macs with 41.7 GiB of resident weights, reading the n-gram table from SSD; we have not tested it. Our M5 Ultra Mac Studio guide and desk-side hardware comparison cover the machines.

Qwen 3.8 Flash Next vs 27B vs GLM-5.3-Flash vs DeepSeek V4.1 Flash

Qwen’s own scores put Flash-Next ahead of the 27B on agent work: 62.5 against 61.7 on SWE-bench Pro, 58.7 against 42.2 on DeepSWE 1.1 and 73.9 against 70.7 on CoWorkBench. Other vendors use other harnesses, so test on your own tasks.

Against GLM-5.3-Flash, Flash-Next activates a third as many parameters per token and fits a 128 GB machine at 4-bit, where GLM’s 157 to 200 GB builds need 256 GB; GLM answers with a native 1M-token window and an MIT licence, as our GLM-5.3 sizing guide details. Our DeepSeek V4.1 Flash hardware guide covers the heaviest of the four.

Qwen 3.8 licences: Apache 2.0, Community and Max

• Qwen3.8-27B: Apache 2.0, with no conditions beyond its usual notice terms.
• Qwen3.8-Flash-Next: Qwen Community License 1.0. An MIT-style grant with two conditions. Products above 100 million monthly active users or US$20 million in monthly revenue must display the model name. A licensee whose group runs a Model-as-a-Service or AI Work Assistant business, meaning an independent coding or office-productivity product, must “obtain a separate license from Qwen before Using the Software” commercially, whatever its revenue. Internal use is exempt while the software, its outputs and its capabilities stay away from third parties.
• Qwen3.8-2.4T-A95B: Qwen3.8-Max License. The same text, except that the separate licence applies only above US$50 million of group revenue in any 12 consecutive months.

NVIDIA’s Flash-Next NVFP4 build adds its own Open Model License. Our Qwen size-tier guide for enterprise teams compares Qwen3.5, 3.6 and 3.8 at scale.

How VDF AI fits

A Qwen3.8 server answers anyone who can reach its port. Work use also needs rules for who may send which data, a record of each request, and retrieval that respects document permissions. VDF AI supplies that layer on infrastructure you control, with policy-bound agents, multi-agent workflows in Networks, private document retrieval, audit logs and role-based access control on every plan.

VDF AI Router can register your own endpoints, such as vLLM serving Qwen3.8-27B or an Ollama host running Flash-Next, beside the cloud models your policy approves; in air-gap mode it sends nothing beyond local models. A team can start with the 27B on one GPU and add Flash-Next later without changing the applications that call the router.