How Much VRAM Does Ling 3.0 Flash Need?
81.1 GB at the official FP4 build, or 86.2 GB at Q4_K_M, both including runtime overhead at an 8K context. Ling 3.0 Flash, published as inclusionAI/Ling-3.0-flash, is a 124B mixture-of-experts model with 5.1B parameters active per token, released on August 4, 2026 under an MIT license. The Ling 3.0 Flash VRAM requirements land in an unusual place: small enough for a single 128 GB unified-memory machine, at a parameter count that normally means a server.
The official FP8 build does not fit that machine. The official FP4 build does, comfortably. Both shipped on the same day, and that distinction is the practical story.
| Build | Weights on disk | Total at 8K | Total at 256K | Fits one 128 GB box |
|---|---|---|---|---|
| FP4 (MXFP4), official | 70.40 GB | 81.1 GB | 83.5 GB | Yes |
| INT4, official | 77.01 GB | 88.7 GB | 91.1 GB | Yes |
| Q4_K_M, community GGUF | 74.84 GB | 86.2 GB | 88.6 GB | Yes |
| FP8, official | 128.44 GB | n/a | n/a | No |
| BF16, official | 254.98 GB | n/a | n/a | No |
Every figure in the first column is a measured file size from Hugging Face. The totals are computed by our VRAM calculator from the model’s real layer structure, adding KV cache and 15% runtime overhead. Sizes throughout are decimal GB, bytes divided by a billion, which is the same convention we use everywhere on the site.
The Single Box Question
When the weights landed, the discussion among people running local models on a DGX Spark or a Framework Desktop went straight to whether 124B fits in 128 GB. The reasonable-sounding answer was that FP8 gets close but leaves nothing for context, and that the thing to do is wait for an NVFP4 build.
The measured numbers say something simpler. The FP8 weights total 128.44 GB. That is larger than the entire memory of a 128 GB machine before a single token of context is allocated, before the runtime loads, before the operating system takes its share. It is not close, and no assumption about overhead is needed to reach that conclusion.
It also does not matter, because the wait for a 4-bit build was over before it started. inclusionAI published FP4 and INT4 themselves on launch day, alongside BF16 and FP8. The FP4 build is 70.40 GB of weights. On a 128 GB box that leaves roughly 58 GB for context, runtime and operating system, which is a comfortable margin rather than a tight one.
One caveat on the box itself. The 128 GB on a DGX Spark is unified memory shared with the operating system, so the amount available to a model is lower than the number on the label. Simon Willison, testing one hands-on, reported roughly 112 GB actually available. The FP4 build clears that. FP8 does not clear either figure.
Why 256K Context Costs Almost Nothing
This is the part that makes the model interesting beyond its size, and it is the reason the fit is comfortable rather than marginal.
Ling 3.0 Flash has 42 layers, and they are not the same kind of layer. Thirty-five use Kimi Delta Attention, a linear mechanism that holds a fixed-size recurrent state. That state is the same size at 200,000 tokens as it is at 200. Only the remaining seven use Gated MLA, and only those seven hold a cache that grows with context.
| Context | KV cache | Total at Q4_K_M |
|---|---|---|
| 8K | 0.146 GB | 86.2 GB |
| 32K | 0.345 GB | 86.5 GB |
| 128K | 1.137 GB | 87.4 GB |
| 256K | 2.194 GB | 88.6 GB |
Going from 8K to the full 256K context, a 32x increase, costs 2.0 GB. On a conventional 42-layer model at this width, every layer would be caching, and the same jump would cost roughly six times that.
The arithmetic is checkable. The seven MLA layers cache a 576-value latent per token, which is kv_lora_rank 512 plus qk_rope_head_dim 64 from the model’s own config.json. The thirty-five KDA layers hold a recurrent state of 32 heads x 128 x 128, plus three short-convolution states, and none of it moves with context.
We derived the 35 and 7 split from the model’s own code, where a layer becomes a full attention layer when (layer_idx + 1) % layer_group_size == 0. With a group size of 6 across 42 layers that gives layers 5, 11, 17, 23, 29, 35 and 41: seven of them. The model card states the same split independently as “35 KDA + 7 Gated MLA (5:1)”.
Every Published Build
| Build | Source | Weights on disk | Note |
|---|---|---|---|
| BF16 | inclusionAI, official | 254.98 GB | Two boxes, or a server |
| FP8 | inclusionAI, official | 128.44 GB | Larger than a 128 GB box on its own |
| INT4 | inclusionAI, official | 77.01 GB | Fits, with headroom |
| FP4 (MXFP4) | inclusionAI, official | 70.40 GB | Smallest official build |
| Q4_K_M | community GGUF | 74.84 to 79.30 GB | Varies by builder and imatrix |
| MXFP4_MOE | community GGUF | 69.85 GB | Close to the official FP4 |
| IQ1_S | community GGUF | 26.69 GB | The floor, expect real quality loss |
The Q4_K_M range is real and worth noting. Different builders produce different sizes from the same model depending on their importance matrix and which tensors they promote, so a Q4_K_M is not one fixed number. Our calculator computes 75.2 GB of weights for this model at Q4_K_M, which sits inside the measured range and within 1% of the smallest published file.
What You Need To Run It
One practical obstacle, and it is the kind that turns a ten-minute download into an afternoon.
llama.cpp does not support this architecture out of the box as of August 5, 2026. Support for BailingMoeV2, the previous generation, was merged in October 2025. Ling 3.0 Flash is BailingMoeV3 with a bailing_hybrid model type, and that is a different code path because of the KDA layers. One of the GGUF publishers ships a bailing-hybrid-llama.cpp.patch alongside the weights, which is not something anyone does for an architecture already merged upstream.
So a GGUF download today likely needs a patched build. This is the sort of thing that changes within weeks of a launch this size, so check the current state before assuming either way. The official FP4 and FP8 builds are safetensors intended for vLLM and similar servers, and follow a different path entirely.
What We Do Not Know Yet
Two honest gaps, both worth stating plainly rather than filling with estimates.
No independent measurement of this model exists yet. No third-party tokens per second, no memory traces, no quality evaluations. The weights are hours old at the time of writing. Community members have said they are pulling them onto Spark hardware to test, and when those numbers arrive they will be worth more than any projection, including ours. We do not own hardware and we do not benchmark, so every number on this page is computed memory, not measured speed.
The launch benchmarks cannot be checked. inclusionAI published its comparison against MiniMax-M2.7, DeepSeek-V4-Flash and Claude Sonnet 4.6 as chart images, with no numeric table and no technical report. We normally test a vendor’s benchmark table by checking whether its scores for third-party models match those vendors’ own published figures, because a table that disagrees with everyone cannot be read across. Here there are no readable numbers to run that check against, so we are not reproducing the claims. When a technical report appears, that changes.
What the memory figures do not tell you is speed. A 5.1B active parameter count means this model reads far less per token than its 124B total suggests, which is the usual reason a model like this feels quicker than its size. How that lands in practice on a specific box is a measurement, and it has not been taken.
Check what fits your own GPU, or size Ling 3.0 Flash against your hardware directly in the calculator, which now carries it with the real 35 and 7 layer split.
Read more: Running DeepSeek V4 Flash on a DGX Spark | Chinese Open-Weight Models Top the Leaderboards | Renting a GPU Is the Cheaper Way to Try It
FAQ
How much VRAM does Ling 3.0 Flash need?
At the official FP4 build, 81.1 GB at an 8K context and 83.5 GB at the full 256K, including runtime overhead. At Q4_K_M the figures are 86.2 GB and 88.6 GB. The BF16 build needs 255 GB and is a two-machine job.
Does Ling 3.0 Flash fit on a DGX Spark?
At FP4, INT4 or any 4-bit GGUF, yes, with room for full context. At FP8 or above, no. The FP8 weights alone are 128.44 GB, which exceeds the machine’s entire 128 GB before anything else loads, and the usable figure is lower still because the memory is shared with the operating system.
Do I need to wait for an NVFP4 build?
No. inclusionAI published official FP4 and INT4 builds on launch day, August 4, 2026, alongside BF16 and FP8. All four are MIT licensed. Community NVFP4 and MXFP4 conversions also exist.
How many parameters is Ling 3.0 Flash?
124B total with 5.1B active per token. The safetensors index totals 127.49B, and the difference is the multi-token-prediction module, which GGUF conversion drops. 124B is both the vendor’s headline figure and what actually loads for inference.
Why does long context cost so little on this model?
Because only 7 of its 42 layers cache anything that grows. The other 35 use Kimi Delta Attention, which holds a fixed recurrent state that is the same size at any context length. Moving from 8K to 256K costs 2.0 GB of KV cache in total.
What license is Ling 3.0 Flash under?
MIT, across all four official repositories. That is among the most permissive licenses in open weights, with no revenue cap and no regional restrictions.
Can llama.cpp run Ling 3.0 Flash?
Not from a stock build as of August 5, 2026. BailingMoeV2 support was merged in October 2025, but this model is BailingMoeV3 with a bailing_hybrid type and a different code path. At least one GGUF publisher ships a llama.cpp patch alongside the weights. Check the current state before downloading, because this typically changes quickly after a launch.
What context length does Ling 3.0 Flash support?
262,144 tokens, set by max_position_embeddings in config.json. The model card describes a training schedule of 8K, then 32K, then 256K.
How does it compare to DeepSeek V4 Flash?
On memory, Ling 3.0 Flash is the smaller of the two: 124B against 284B total. Both are sparse enough to run far below what their totals suggest. On quality we are not making a comparison, because inclusionAI published its benchmark results as chart images with no numeric table, and we do not reproduce figures we cannot read or check.
Is there an official GGUF?
Not from inclusionAI. The official builds are safetensors in BF16, FP8, INT4 and FP4. GGUF conversions come from the community, and at least three repositories published them within a day of launch, spanning IQ1_S at 26.7 GB up to BF16 at 249 GB.
Has anyone measured its actual speed?
Not independently, as of August 5, 2026. The weights are a day old. We compute memory, not throughput, and we own no hardware to benchmark on, so we will not estimate tokens per second. Community measurements on Spark-class hardware are expected within days.