VRAMNeeded Calculator

Alibaba Qwen (pruned by ISTA-DASLab / AgentionAI) · VRAM requirements

Qwen3.8-Flash-Next Coder VRAM: which pruned build fits 12, 16, 24 or 32 GB?

  • Parameters176.9B base, half the experts kept (6B active in the base)
  • Context256K
  • Resident weights29.6 GB
  • Checked2026-10-29

Quick answer

The Coder builds of Qwen3.8-Flash-Next only need their first shard in GPU memory. ISTA-DASLab's GSQ-RCO Coder keeps 29.6 GB resident; its 28.8 GB n-gram shard can stay in system RAM or on disk.[1][2] With an 8K context that is about 29.8 GB, so it is tight on a 32 GB RTX 5090 and comfortable on 48 GB.[3][13] On a 24 GB RTX 3090 or 4090, the smallest all-GPU option is AgentionAI's Gyro-Coder (19.92 GiB, about 21.4 GB), but stock llama.cpp cannot load it.[4] On 12–16 GB cards it only runs with experts offloaded to system RAM (around 32 GB of RAM), not fully in VRAM.[6][7]

"Qwen3.8-Flash-Next Coder" is not one official Qwen release. It is the name people use for expert-pruned versions of Qwen3.8-Flash-Next that keep only the experts that matter for code. The original is ISTA-DASLab's GSQ-RCO Coder GGUF. Its Hugging Face repo was created on September 26, 2026, and had 1,059,206 downloads when we checked on October 29, 2026.[1][2] It keeps 256 of the 512 experts in each of the 48 layers and stores them at about 3.5 bits per weight.[1] Community builds based on it, like Gyro-Coder and a 192-expert version, cut it down further for 24 GB cards and pairs of 16 GB cards.[4][5]

Why it gets asked about so much: the full Flash-Next has 176.9B parameters and is 354 GB at BF16.[1] Even its smallest standard GGUFs are over 66 GB (see the Flash-Next page). The Coder builds are the ones people actually run on gaming GPUs. ISTA-DASLab's updated build (October 17, 2026) reports 79.20 on SWE-bench Verified against 82.80 for the BF16 base (95.7% kept) and the same LiveCodeBench v6 score (87.43). These are the developer's own scores, measured at "xhigh" reasoning effort.[1] Outside code it is weaker: both ISTA-DASLab and Strata say to use an unpruned build for general use.[1][6]

Memory needed for each Coder build

These builds come as two parts: the transformer weights, which have to sit in GPU (or unified) memory for full speed, and a large n-gram lookup table, which does not. ISTA-DASLab says the n-gram shard "may be served from disk". Gyro's card says to keep it on a fast NVMe drive with --ngram-on-disk.[1][4] So the table below shows only the part that has to be resident, not the download size. File sizes are from Hugging Face (1 GB = 1,000,000,000 bytes). Gyro sizes are the GiB values on its model card, converted to GB.[2][4][5]

QuantizationWeights
GSQ-RCO Coder IQ1_M ISTA-DASLab, shard 1 (must be resident); stock llama.cpp29.6 GB
Gyro-Coder-L 27.54 GiB GPU weights; needs AgentionAI's llama.cpp build29.6 GB
Coder-192E community build, shard 1; made for two 16 GB GPUs23.3 GB
Gyro-Coder 19.92 GiB GPU weights; needs AgentionAI's llama.cpp build21.4 GB
Build Download (all files) GPU-resident part n-gram table (RAM or disk) Runs in
ISTA-DASLab GSQ-RCO Coder (IQ1_M) 58.4 GB (2 shards) 29.6 GB 28.8 GB llama.cpp with Flash-Next support; Strata
Coder-192E (oisee, community) 52.1 GB (2 shards) + 3.0 GB optional MTP head 23.3 GB 28.8 GB Recent llama.cpp master
Gyro-Coder-L (AgentionAI) 78.2 GiB 27.54 GiB (29.6 GB) rest of file AgentionAI's llama.cpp build (Docker)
Gyro-Coder (AgentionAI) 70.6 GiB 19.92 GiB (21.4 GB) 50.7 GiB AgentionAI's llama.cpp build (Docker)

Sources: ISTA-DASLab and 192E file lists; Gyro model card.[2][4][5] Gyro's TQ2_0 / TQ3_0 names are only size labels, and its card says stock llama.cpp cannot load these files. Strata 0.2.2 does not support them yet either.[4] The 192E build needs a llama.cpp build with the Flash-Next (qwen4exp) architecture. Older builds will not load it.[5] ISTA-DASLab's repo also has a 0.9 GB vision projector (mmproj) that is not counted here.[2]

Context length adds memory (the KV cache)

Pruning removes experts, not attention layers. The 192E card says nothing else (attention, shared expert, n-gram table) is changed, so the KV cache matches the base model.[5] From the base config.json, only 12 of the 48 layers are Qwen Sparse Attention layers that keep a growing cache. The other 36 are Gated DeltaNet layers with a fixed-size state.[3] With 2 KV heads and a head size of 256, an FP16 cache takes 2 × 12 × 2 × 256 × 2 bytes = 24,576 bytes per token (our calculation from the config):

ContextKV cache (FP16, 12 attention layers)
4,096 tokens0.10 GB
8,192 tokens0.20 GB
32,768 tokens0.81 GB
262,144 tokens6.44 GB

So the full 262,144-token context adds only about 6.4 GB at FP16, or roughly half that with an 8-bit cache. That is why the two-16 GB-card build can run a 194,560-token context (-c 194560) with a q8_0/q5_1 cache.[5] The small QSA indexer cache and the fixed DeltaNet state are not in the table. Qwen has not published sizes for them.

Which GPUs hold it fully

Each cell compares the GPU-resident weights plus an 8K-token FP16 cache with the card's memory.[9][10][11][12][13][14]

DeviceGSQ-RCO Coder IQ1_M29.8 GBGyro-Coder-L29.8 GBCoder-192E23.5 GBGyro-Coder21.6 GB
RTX 306012 GBNoNoNoNo
RTX 5060 Ti16 GBNoNoNoNo
RTX 309024 GBNoNoTightFits
RTX 409024 GBNoNoTightFits
Two 16 GB GPUs32 GBTightTightFitsFits
RTX 509032 GBTightTightFitsFits
RTX 6000 Ada48 GBFitsFitsFitsFits

Column headers show the GPU-resident weights + an 8,192-token FP16 KV cache (12 attention layers). Not included: the n-gram table (28.8 GB for the ISTA-DASLab and 192E builds, 50.7 GiB for Gyro), which stays in system RAM or on an NVMe SSD, the 0.9 GB vision projector, an optional MTP draft head, engine buffers and the OS/display. Below 24 GB, see 'Running it on 12–16 GB'.

How to read it: "Fits" means under 90% of memory, "Tight" means 90–100%, and "No" means it won't fit fully on that device. The 90% line is our own rule of thumb. The "Two 16 GB GPUs" row adds the cards together. Splitting across two cards costs some extra memory, and the 192E authors needed a tensor split (-ts 28,21) and the token embedding on the CPU to make it fit.[5] Macs are left out: Gyro's instructions only cover Vulkan in Docker on AMD, Intel and NVIDIA GPUs, and we found no Mac report for the Coder builds to check against.[4]

What this means in practice:

  • 32 GB (RTX 5090): ISTA-DASLab's Coder or Gyro-Coder-L fits tightly at short contexts. Use an 8-bit KV cache for long contexts. ISTA-DASLab's card says the resident set is "within the capacity of a single 32 GB accelerator".[1]
  • 24 GB (RTX 3090 / 4090 / 7900 XTX): Gyro-Coder is the build that targets this tier. Its card lists 21.1 GiB with a 64K context and q8_0 KV cache.[4] The 23.3 GB 192E shard is too tight for one 24 GB card.
  • Two 16 GB cards: this is what the 192E build was made for: "zero experts in RAM", about 4 GB of VRAM left free at 192K context without the MTP head.[5]

Running it on 12–16 GB (offloading)

Below 24 GB, none of these builds fits in VRAM, but the Coder still runs if you keep the experts in system RAM. Strata, a third-party llama.cpp-based engine, loads shard 1's experts into RAM and the rest onto the GPU, and leaves the 29 GB lookup table on the SSD. It lists 23 GB of experts for the Coder and says the model fits when RAM is at least the experts plus about 10 GB.[6] Strata says a 32 GB-RAM PC with a 12–16 GB GPU runs the Coder in its low-RAM mode, where most experts come from the SSD and "it is much slower".[6]

Measured speeds (Strata's own numbers, measured on older engine versions; not tested by us):[6]

Hardware Short chat 128K context 32K prompt read
RTX 5070 12 GB + 64 GB RAM (engine 0.1.26) 55 tok/s 43 tok/s 2,180 tok/s
RX 9070 XT 16 GB + 47 GB RAM (before engine 0.1.40) 44 tok/s 33 tok/s 1,420 tok/s

Third-party reports (not verified by us): one X user ran the IQ1_M Coder on an RTX 3060 12 GB with 31 GB of RAM (Strata 0.1.52, 32K context, 8-bit KV, MTP on). They reported about 20.8 tok/s generation, 10.9 GB of VRAM used and 30.7 of 31 GB of RAM used, so 32 GB of RAM is right at the limit.[7] Another listing reports 127 tok/s at 154K context on an RTX 5060 Ti 16 GB plus an RTX 3070 8 GB with 32 GB of RAM (Strata 0.1.44, 97% MTP draft acceptance).[8] Speeds depend heavily on RAM and SSD bandwidth, MTP acceptance and the engine version.

How to run it

  • llama.cpp (ISTA-DASLab build): download both shards and point llama.cpp at the first one. It loads the pair automatically (-m IQ1_M/Qwen3.8-Flash-Next-GSQ-RCO-IQ1_M-00001-of-00002.gguf -ngl 99).[1] You need a recent llama.cpp with Flash-Next support.
  • Two 16 GB GPUs (192E): the 192E card has the full llama-server command, including --device CUDA0,CUDA1, -ts 28,21, -otd token_embd=CPU and -ctk q8_0 -ctv q5_1. It also ships a patched chat template for agent clients like Claude Code, which otherwise fail on mid-conversation system messages.[5]
  • 24 GB card (Gyro-Coder): use AgentionAI's Docker image with --ngram-on-disk -c 65536 -ctk q8_0 -ctv q8_0, and keep the file on a fast NVMe drive.[4] Gyro-Coder-L was updated to v1.2 on October 29, 2026, under the same file name, to fix broken tool-call tags. If you downloaded it earlier, download it again.[4]
  • 12–16 GB card: strata launch --family coder --model IQ1_M (Strata docs). Read the launch plan first: it shows the RAM it expects.[6]

If you downloaded ISTA-DASLab's build before October 17, 2026, download shard 1 again. Only that shard changed in the update.[1]

Cheapest GPU to rent for Qwen3.8-Flash-Next Coder

A 32 GB RTX 5090 holds the ISTA-DASLab Coder tightly, and a 48 GB card holds it comfortably with room for long context. Leave system RAM or disk space for the 28.8 GB n-gram shard. On-demand Secure Cloud prices listed on Runpod's pricing page:[15]

GPU (Runpod Secure Cloud (on-demand, as listed))VRAMPrice
RTX 309024 GB$0.50/hr
RTX 409024 GB$0.89/hr
RTX 509032 GB$1.19/hr
RTX A600048 GB$0.59/hr
RTX 6000 Ada48 GB$0.99/hr

Prices checked on 2026-10-29. They change often, so confirm on the provider's page. System RAM is Runpod's listed figure per pod; the n-gram table needs room there or on disk. Rent on Runpod Referral link

Rent a GPU for this model
Affiliate partnerVast.aiConsumer GPU marketplace (4090/3090-class rentals)See GPUs →Referral linkRunpodPods and serverless GPUsSee GPUs →Works withE2E NetworksIndia GPU cloudSee GPUs →
Run it via API instead
Affiliate partnerNovita AI model APIsBrowse open models you can call through Novita's API instead of hosting them.Browse model APIs →Affiliate partnerNovita SandboxCloud runtimes for AI agents: browser access, filesystem, computer use, long-running tasks.See Sandbox →

Don't want to host it yourself? Compare AI APIs and Sandboxes.

Where to rent or buy

Run it on a cloud GPU

  • Vast.ai Affiliate partner Consumer GPU marketplace (4090/3090-class rentals)
  • Runpod Affiliate partner Pods and serverless GPUs (referral link)
  • E2E Networks Works with India GPU cloud (official site)

Run it via API instead

  • Novita AI Affiliate partner Open-model APIs and Sandbox for AI agents (no GPU rental)

Buy this GPU (or a Mac)

  • B&H Photo Works with GPUs and computing gear (official site)

We may earn from links marked Affiliate partner. Disclosure.

Frequently asked questions

Can I run Qwen3.8-Flash-Next Coder on an RTX 3090 or RTX 4090?

Fully on the GPU, only with Gyro-Coder (19.92 GiB of weights, 21.1 GiB with a 64K q8_0 cache), which needs AgentionAI's llama.cpp build.[4] ISTA-DASLab's standard Coder needs 29.6 GB resident, so on 24 GB it runs with some experts offloaded to system RAM. Strata does this automatically.[2][6]

Does it fit on an RTX 5090 (32 GB)?

Yes, tightly. The resident shard is 29.6 GB, plus about 0.2 GB of cache at 8K tokens, which is about 93% of 32 GB.[2][13] Use an 8-bit KV cache and keep other GPU apps closed for longer contexts.

Can I run it on a 12 GB RTX 3060?

Not in VRAM alone, but it runs with offloading. One user reports about 20.8 tok/s on an RTX 3060 with 31 GB of RAM, using 10.9 GB of VRAM. Their RAM was almost full, so 32 GB is the practical minimum and 64 GB is more comfortable.[7][6]

Do I need VRAM for the 28.8 GB n-gram shard?

No. It is a lookup table, not a matrix-multiply weight. ISTA-DASLab says it may be served from disk, the 192E setup keeps it in system RAM, and Gyro reads its table from disk.[1][4][5]

Is the Coder as good as the full Flash-Next?

For code it is close by the developers' own numbers: 79.20 vs 82.80 on SWE-bench Verified, and an equal score on LiveCodeBench v6.[1] Outside code it is weaker: Strata notes weaker results in languages other than English, AgentionAI flags symbol tables as a weak spot, and both ISTA-DASLab and AgentionAI recommend unpruned builds for general use.[1][4][6]

How we calculated

  • Weights are the GPU-resident part only. For ISTA-DASLab and 192E that is the exact size of shard 1 on Hugging Face. For Gyro it is the "GPU memory (weights)" figure on its model card, converted from GiB.[2][4][5]
  • KV cache is calculated from the base model's config.json (12 attention layers, 2 KV heads, head size 256) at FP16.[3] Pruning does not change these layers.[5]
  • Device memory is from NVIDIA spec pages. We compare in decimal GB.
  • Not included: the n-gram table (kept in RAM or on disk), the vision projector, MTP draft heads, engine buffers and the OS/display. Leave headroom.

Sources

All sources checked on .

  1. Hugging Face, ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-Coder-GGUF model card (experts kept, resident vs n-gram shard, October 17, 2026 update, benchmarks; developer-reported; checked October 29, 2026). https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-Coder-GGUF
  2. Hugging Face, ISTA-DASLab Coder GGUF file list (shard sizes 29,608,446,496 and 28,800,138,432 bytes; repo created September 26, 2026; downloads). https://huggingface.co/ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-Coder-GGUF/tree/main
  3. Hugging Face, Qwen/Qwen3.8-Flash-Next config.json (layer types, KV heads, head size, context). https://huggingface.co/Qwen/Qwen3.8-Flash-Next/blob/main/config.json
  4. Hugging Face, agentionai/Qwen3.8-Flash-Next-Gyro-Coder-GGUF model card (GPU memory per file, runtime, n-gram on disk, v1.2 update October 29, 2026; developer claims). https://huggingface.co/agentionai/Qwen3.8-Flash-Next-Gyro-Coder-GGUF
  5. Hugging Face, oisee/Qwen3.8-Flash-Next-GSQ-RCO-Coder-192E-GGUF model card (two 16 GB GPU setup, file sizes, llama.cpp flags; community build). https://huggingface.co/oisee/Qwen3.8-Flash-Next-GSQ-RCO-Coder-192E-GGUF
  6. Strata documentation, "Which model? Sizes, versions and what fits" (Coder RAM rule, low-RAM mode, measured speeds; third-party engine). https://github.com/Niko1221/Strata/blob/main/docs/MODELS.md
  7. @Oluwaphilemon1 on X, Qwen3.8-Flash-Next Coder on an RTX 3060 12 GB (third-party report, October 29, 2026). https://x.com/Oluwaphilemon1/status/2115959244088390062
  8. OpenWeights Terminal, Qwen3.8-Flash-Next Coder on RTX 5060 Ti 16 GB + RTX 3070 8 GB (quotes a user report by @VectorCrossProd; not independently verified; checked October 29, 2026). https://owterminal.com/pair/flash-next-coder-iq1m-strata-5060ti-3070-vector
  9. NVIDIA, GeForce RTX 3060 family (12 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/30-series/rtx-3060-3060ti/
  10. NVIDIA, GeForce RTX 5060 family (RTX 5060 Ti 16 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/50-series/rtx-5060-family/
  11. NVIDIA, GeForce RTX 3090 specs (24 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/30-series/rtx-3090-3090ti/
  12. NVIDIA, GeForce RTX 4090 specs (24 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/40-series/rtx-4090/
  13. NVIDIA, GeForce RTX 5090 specs (32 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/50-series/rtx-5090/
  14. NVIDIA, RTX 6000 Ada Generation (48 GB). https://www.nvidia.com/en-us/products/workstations/rtx-6000/
  15. Runpod, GPU pricing (checked October 29, 2026). https://www.runpod.io/pricing

Last checked: