One-line positioning: This is Alibaba’s open-weight preview of the Qwen4 architecture. 125B total params, only 6B activated, and the smallest 1-bit build runs on 75GB of memory — but if you only have a consumer GPU plus RAM, “VRAM too small, use the SSD” really does work.
1. TL;DR
- Identity: Alibaba Qwen’s 2026-08-26 open-weight preview of the Qwen4 architecture. Main model 125B + 51B N-gram embedding + 4B MTP, 6B activated per token.
- Context: Native 262K tokens, extensible to 1M with YaRN. Prefill throughput at 1M context is 8.6x Qwen3.7-Plus.
- Architecture innovation: GDN (Gated DeltaNet) + QSA (Qwen Sparse Attention) hybrid attention, plus Gated Residual and the Muon optimizer. This is the first open-weight model with this combination.
- Local deployment bar: Unsloth provides a full GGUF quant ladder from 1-bit (~75GB) to BF16 (~355GB). 24GB VRAM + 64GB RAM + NVMe SSD is enough to run IQ4_XS.
- Hands-on results: IQ4_XS wrote a working parkour game in one shot. The 1-bit build autonomously coded a 3D FPS shooter over 5 hours 22 minutes, producing 429K output tokens.
- Benchmarks: With only 6B activated, it beats Qwen3.8-27B and Qwen3.7-Plus on 8 of 14 benchmarks (DeepSWE 58.7, SWE-bench Pro 62.5, CoWorkBench 73.9, LiveCodeBench v6 91.9).
- Production version: Qwen3.8-Flash on Qwen Cloud is priced at 0.16 USD per million input tokens, 0.47 USD per million output tokens.
2. Quick Specs
| Item | Spec |
|---|---|
| Vendor | Alibaba Qwen Team |
| Release date | 2026-08-26 |
| Main parameters | 125B (plus 51B N-gram embedding + 4B MTP, ~180B total) |
| Activated parameters | 6B per token |
| Layers | 48 layers (12× [3× GDN+MoE → 1× QSA+MoE]) |
| Experts | 512 total, 10 routed + 1 shared activated |
| Context | Native 262,144 tokens, extensible to 1,000,000 with YaRN |
| Architecture | GDN + QSA hybrid attention, Gated Residual, Muon optimizer |
| Quantization | Unsloth GGUF, from 1-bit (~75GB) to BF16 (~355GB) |
| Inference stacks | llama.cpp (qwen4exp branch), SGLang, vLLM, Unsloth Desktop, TokenSpeed |
| Production version | Qwen3.8-Flash on Qwen Cloud, $0.16 / $0.47 per 1M tokens |
| Training cost | Roughly 1/9 of Qwen3.7-Plus |
3. Why This Release Matters
In short, the Qwen team is doing two things at once: pushing parameters and context longer, and pushing single-inference cost toward a new low. Qwen3.8-Flash-Next is where those two lines meet — the first 125B-class model that only activates 6B per token, paired with 1M context and a step-function drop in training and inference cost.
Three points matter most for local-deployment users:
- Small activation (6B), big capability — at 6B activated it still beats the 27B dense Qwen3.8-27B on 8/14 benchmarks. Hardware bar is similar to a 27B dense model, but the ceiling is one tier higher.
- Full quant ladder — from 1-bit to BF16, in clean steps. 1-bit runs on 75GB of memory, 4-bit holds steady at 111GB, BF16 (~355GB) is for research and head-to-head comparison.
- GDN + QSA hybrid architecture — a Qwen4 preview. GDN handles efficient memory, QSA handles precise retrieval. At 1M context, Prefill is 7.6x faster and Decode is 4.9x faster than Qwen3.7-Plus.
Add the 1/9 training cost and it is hard to avoid the conclusion: this architecture is going to be the backbone of the Qwen4 family.
4. Official Resources and Download Links
In the order I recommend. All official mirrors plus backup mirrors are listed:
| Resource | Link | Notes |
|---|---|---|
| Hugging Face (Unsloth quants) | https://huggingface.co/unsloth/Qwen3.8-Flash-Next-GGUF/tree/main | The recommended source, full 1-bit to BF16 ladder |
| ModelScope | https://modelscope.cn/models/Qwen/Qwen3.8-Flash-Next | Friendlier in mainland China |
| GitHub repo | https://github.com/QwenLM/Qwen3.8-Flash-Next | Tech report and quickstart |
| Official blog | https://qwen.ai/blog?id=qwen3.8-flash-next | Architecture deep dive and benchmark table |
| Backup domestic mirror | https://pan.quark.cn/s/277ea7e7bde2 | Quark cloud drive, direct in China |
| Backup high-speed mirror | https://git.cloudeop.com/repo.php?id=115b6ac9 | Overseas CDN, accessible from China |
| TDM Fast downloader | https://www.tdmfast.com/ | Paid, but the fastest way to pull large model files |
5. Local Deployment Guide (Four Steps)
5.1 Hardware
- Minimum: 64GB RAM + 24GB VRAM + 2TB NVMe SSD (for IQ4_XS or 1-bit)
- Recommended: Single 96GB GPU, or two 96GB GPUs (for full 4-bit load)
- Enthusiast: 256GB Mac Studio (M3/M5 Ultra) can fully load the 1-bit quant
5.2 Download the GGUF
The model repo is live on Hugging Face. Unsloth’s quants are clean and well-organized — the file list goes 1-bit to BF16 in a single page.
The repo lists 11 quants: BF16, Q8_0, UD-IQ1_M, UD-IQ1_S, UD-IQ3_XXS, UD-IQ4_XS, UD-Q2_K_XL, UD-Q3_K_XL, UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL. On my 64GB RAM + 24GB VRAM machine I picked UD-IQ4_XS — 4 shards, around 80GB total.
Heads-up: Hugging Face’s new Xet backend sometimes drops large file downloads into KB/s territory. Disable it before pulling:
pip install -U huggingface_hub
export HF_HUB_DISABLE_XET=1Then pull all four shards in parallel:
hf download unsloth/Qwen3.8-Flash-Next-GGUF \
"UD-IQ4_XS/Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00004.gguf" \
--local-dir ./Qwen3.8-Flash-Next-GGUF &
# Repeat 4 times, swap to 00002/00003/00004, then wait5.3 Install llama.cpp
Qwen3.8-Flash-Next uses a new architecture (GDN + QSA + N-gram), so the standard llama.cpp release does not yet recognize this model. You have to use the Unsloth-maintained qwen4exp/qwen3.8-flash-next branch.
The main GitHub repo (https://github.com/ggml-org/llama.cpp) can be slow from China; a domestic mirror is also available:
- Official GitHub: https://github.com/ggml-org/llama.cpp
- Domestic cloud drive: https://pan.quark.cn/s/538d8af25774
5.4 One-Click Launcher
I packaged a one-click launcher — double-click to run, parameters preset. Drop it into the llama.cpp root, drop the model into a models/ subfolder, and it just works.
- Domestic cloud drive: https://pan.quark.cn/s/1f4750f51f5e
- Overseas cloud drive: https://pan.cloudeop.com/s/313241A25799B60B
If you want to drive it from the command line instead, the DataCamp walkthrough (original) has a clean reference command. The key flags are these:
./build/bin/llama-server \
-m ./models/Qwen3.8-Flash-Next-UD-IQ4_XS-00001-of-00004.gguf \
--alias qwen3.8-flash-next \
--host 0.0.0.0 \
--port 8080 \
--ctx-size 131072 \
--parallel 1 \
--flash-attn on \
--fit on \
--fit-target 4096 \
--jinja \
--batch-size 1024 \
--ubatch-size 512 \
--temp 1.0 \
--top-p 0.95 \
--top-k 20 \
--min-p 0.0--fit on plus --fit-target 4096 is the magic combo: it lets llama.cpp automatically split the model between GPU and host memory based on what your machine actually has. This is the technical reason “VRAM too small, use the SSD” works in practice.
5.5 Start and Verify
Double-click the launcher. When you see llama_server: listening on http://127.0.0.1:8080, the model has finished loading.
Open http://127.0.0.1:8080 in a browser, send a “hello” message to test connectivity:
The model replies with “I am Qwen, a large language model developed by Alibaba’s Tongyi Lab” — which proves two things at once: the weights are fully loaded and the tokenizer is configured correctly. The Web UI shows roughly 12 tokens/s.
6. Test 1: Parkour Game (IQ4_XS, One-Shot)
After the basic check passed, I asked it to write “a near-commercial-grade parkour game”: a single-file HTML with Canvas, parallax background, particle effects, combo system, items, daily challenge, audio, and saves.
The model named the game “Neon Pulse” and produced a complete single-file HTML in one shot, running at about 10-13 t/s. The whole job took around 23 minutes including thinking.
What it looks like running:
Parallax background, neon color blocks, scoring system, and the speed bar all work. A 125B model on 24GB VRAM + 64GB RAM at IQ4_XS completing a coding task of this scale was unthinkable a year ago.
7. Test 2: 1-bit Quant Autonomously Develops a 3D Shooter
This was the most surprising test. I switched to the Unsloth UD-IQ1_S 1-bit quant (~75GB) and gave the model a single short prompt: “Build a 3D shooter.”
I gave it no detailed instructions and did not babysit it. A few hours later I opened the logs and saw:
- 5 hours 22 minutes of wall-clock time
- 70M tokens read from cache
- 2.9M fresh input tokens
- 429K output tokens, of which 301K were reasoning
The 1-bit quant was screenshotting its own game, inspecting the result, and fixing what looked off — a behavior I never asked it to perform.
The shooter it produced: a dusk wasteland, first-person view, a 7.62mm MK-47 weapon, wave 2 stage, RAMPAGE x7 combo system, GOD MODE status bar, auto-aim triple-kill:
1-bit quant, 5 hours of autonomous development, 429K output tokens — any one of those would be worth talking about on its own. Stacked together, the only reasonable conclusion is that Qwen4’s architecture keeps high-level agentic coherence even at very low precision.
8. Performance: Official Benchmarks and My Own Runs
Official benchmark highlights
| Benchmark | Qwen3.8-Flash-Next | Qwen3.8-27B | Qwen3.7-Plus | Claude Opus 4.6 Max |
|---|---|---|---|---|
| DeepSWE 1.1 (Agentic coding) | 58.7 | 42.2 | 16.5 | — |
| SWE-bench Pro | 62.5 | 61.7 | 55.8 | 53.4 |
| CoWorkBench (long-horizon office agent) | 73.9 | 70.7 | 65.1 | 68.2 |
| JobBench | 55.7 | 33.4 | 27.6 | 36.6 |
| IFBench | 81.3 | 79.5 | 79.1 | 62.5 |
| GPQA Diamond | 91.7 | 89.2 | 90.3 | 91.3 |
| LiveCodeBench v6 | 91.9 | 90.3 | 89.6 | 88.8 |
| Toolathlon Verified | 73.5 | 67.1 | 50.6 | — |
Source: Qwen3.8-Flash-Next official blog. On 8 of 14 benchmarks, 6B-activated Flash-Next beats the 27B dense model.
My own measured speeds
| Quant | My hardware | Decode speed | Notes |
|---|---|---|---|
| UD-IQ4_XS | 24GB VRAM + 64GB RAM + 2TB NVMe | ~12 t/s | Default thinking on |
| UD-IQ1_S (1-bit) | Same machine | ~30 t/s | Thinking off + reasoning_effort=low |
| UD-Q4_K_XL (cloud reference) | 96GB VRAM | ~30-50 t/s | Community-reported |
9. FAQ
Q1. What is Qwen3.8-Flash-Next and when was it open-sourced?
Alibaba’s Qwen Team released Qwen3.8-Flash-Next on 2026-08-26. It is the early architecture preview of Qwen4 (the same role Qwen3-Next played for Qwen3.5). The main model has 125B parameters with 6B activated per token, native 262K context extensible to 1M. Weights are mirrored on Hugging Face and ModelScope; the production version Qwen3.8-Flash is served on Qwen Cloud.
Q2. My machine only has 24GB VRAM — can I really run a 125B model?
Yes, with caveats. It depends on which quant you pick: 1-bit UD-IQ1_S needs around 75GB of total memory, 2-bit UD-Q2_K_XL needs around 79GB, and 4-bit UD-Q4_K_XL needs around 111GB. I ran UD-IQ4_XS on a 24GB VRAM + 64GB RAM setup with mmap, getting about 12 tokens/s of decode — the model spills over to RAM and SSD. A 128GB Mac Studio can load the 1-bit build comfortably; a 96GB GPU rig will need to offload.
Q3. How good is the 1-bit quant? Is the quality loss noticeable?
Surprisingly good. The 1-bit build keeps the N-gram embedding table near full precision, so common task quality is acceptable — I had it autonomously code a full 3D shooter for 5 hours 22 minutes, reading 70M tokens from cache and producing 429K tokens of output. The main issue is that the 1-bit build’s default reasoning is overlong, so you have to cap reasoning_effort or disable thinking mode explicitly, or token usage will spiral. For everyday coding and agent work I recommend starting at UD-Q2_K_XL, with 4-bit being the safe choice.
Q4. If my VRAM is too small, can I really use the SSD to make up the difference? How much slower is it?
Yes, you can. llama.cpp’s mmap mode streams the model from SSD into RAM and lets the GPU pull what fits. On my 24GB VRAM + 64GB RAM setup with IQ4_XS, decode landed around 12 t/s — about 3-4x slower than full VRAM but much faster than I expected. The hard rule is you need an NVMe SSD; a spinning hard drive will not keep up.
Q5. How do I choose between Qwen3.8-Flash-Next and Qwen3.8-27B?
These are two very different trade-offs. 27B is dense, the activation is the full 27B, and the bar is low — an M1 or M2 MacBook Pro can load the full weights, which makes it the right pick for portable offline work. Flash-Next is the “huge total params + tiny activation + multimodal” route: only 6B activated but you need 75GB+ of total memory to even host the 1-bit build, so it makes sense only on a single high-spec machine where you want to push agentic capability. If you only have one machine, choose 27B; if you have a 96GB GPU rig or a 256GB Mac Studio, choose Flash-Next.
Q6. Can I use Qwen3.8-Flash-Next commercially? What about the pricing?
The open weights themselves are under Apache 2.0, which in principle allows free commercial use including redistribution and fine-tuning for commercial products — but Qwen Team adds a few extra clauses (read the License section on the Hugging Face model card carefully before deploying). If you do not want to self-host, the production Qwen3.8-Flash on Qwen Cloud defaults to 1M context and ships with built-in tools, priced at 0.16 USD per million input tokens and 0.47 USD per million output tokens — about an order of magnitude cheaper than closed-source flagships like Opus.
10. Pros and Cons
✅ Pros
- Early open-weight preview of the Qwen4 architecture — first release with the GDN + QSA hybrid attention
- 125B total params but only 6B activated; the 6B tier beats 27B dense on 8/14 benchmarks
- Native 262K context, extensible to 1M, with 1M-context Prefill throughput 8.6x Qwen3.7-Plus
- Full GGUF quant ladder from 1-bit (~75GB) to BF16 (~355GB), covering consumer to research
- Training cost roughly 1/9 of Qwen3.7-Plus while keeping multimodal, agentic, and coding strength
- Day-0 support across stacks: llama.cpp, SGLang, vLLM, Unsloth Desktop, TokenSpeed
❌ Cons
- Full UD-Q4_K_XL is ~111GB; even the smallest 1-bit build needs 75GB, ruling out most laptops
- 1-bit quant defaults to overlong reasoning; you have to turn off thinking mode in many cases
- Thinking mode is on by default and burns tokens; multi-turn agent tasks need explicit reasoning control
- First deploy needs llama.cpp’s qwen4exp branch — the standard release does not yet recognize this architecture
- No official Ollama tag at release; you have to use the HF repo + llama.cpp CLI manually
11. One-Sentence Summary
Qwen3.8-Flash-Next is not a model for daily use. It is for the people who have 256GB of RAM and want to squeeze every drop of agent capability out of a 125B model — at 1/9 the training cost and 6B activation, it is the ticket into the Qwen4 era.
12. Sources
- Official blog: Qwen3.8-Flash-Next: A New Architecture, Towards Ultimate Cost-Efficiency
- GitHub repo: QwenLM/Qwen3.8-Flash-Next
- Hugging Face model card: Qwen/Qwen3.8-Flash-Next
- Quantization repo: unsloth/Qwen3.8-Flash-Next-GGUF
- Deployment walkthrough: DataCamp — Run Qwen3.8-Flash-Next Locally
- Hardware reference: ModelFit — Qwen3.8-Flash-Next 1-bit hardware notes
- Chinese review: cnblogs — Qwen3.8-Flash overview