llmrun
Inclusion AIBailingMoeV2ForCausalLM

Ling Flash 2.0 — Hardware Requirements & GPU Compatibility

ChatFunctions

Ling-flash-2.0 is Inclusion AI's non-reasoning chat and code model, a mixture-of-experts system with about 102.9 billion total parameters but only roughly 6.15 billion activated per token (4.8 billion non-embedding), built on the Ling 2.0 architecture with a roughly 1/32 expert activation ratio, aux-loss-free routing, multi-token-prediction layers, and partial RoPE. Trained on more than 20 trillion tokens with supervised fine-tuning and multi-stage reinforcement learning, Inclusion AI reports it matches dense models of around 40 billion parameters on complex reasoning, code generation, and frontend-development benchmarks despite its small active-parameter count, while running several times faster thanks to its sparsity. Its small active-parameter footprint keeps generation fast, but all of its parameters must stay in memory, so it needs a multi-GPU setup or a high-memory workstation even once quantized. Context length is natively 32,768 tokens, extendable to 128,000 tokens with YaRN. It is released under the MIT license, permitting unrestricted commercial and research use. It was published in September 2025, alongside the reasoning-focused Ring-flash-2.0 built on the same base.

102.9B params · MoE6.2B active33K contextMIT4.3K downloads222 likes5.6K quant downloads

Doesn't fit a 24 GB GPU

Smallest consumer fit → RTX 5090 · IQ2_XXS · 29.7 GB · ~309 tok/s

Macs from36 GB IQ2_XS · ~82 tok/s

MIT

Not set up for it?

Reference GPU · RTX 4090 24 GB

Estimates, ±20% · how we estimate

Run Ling Flash 2.0

One recommended way. Every other method, OS and quant is in the step-by-step guide.Each way opens a step-by-step guide for your OS and quant.

Ways to runOther ways

each opens step-by-step

Run in cloud

Your own private copy · Q4_K_M · 96 GB GPU

  • The easiest way to try this model
  • Running in a few minutes, easy setup
  • Chat right here or connect any app

$5+ bonus for new users

How Much VRAM Does Ling Flash 2.0 Need?

Select a quantization level; the listed hardware adheres to it.

QuantizationVRAM+32KOn RTX 4090 (reference)
44.2 GB46.2 GB2-bit · K-quant — 2-bit quantization with K-quant improvementsDoes not fit: needs 45.1 GB
45.5 GB47.5 GB3-bit small — 3-bit small quantizationDoes not fit: needs 46.4 GB
50.6 GB52.6 GB3-bit medium — 3-bit medium quantizationDoes not fit: needs 51.5 GB
51.9 GB53.9 GB4-bit · legacy — 4-bit legacy quantizationDoes not fit: needs 52.8 GB
62.2 GB64.2 GB4-bit medium — 4-bit medium quantization — most popular sweet spotDoes not fit: needs 63.1 GB
73.7 GB75.8 GB5-bit medium — 5-bit medium quantization — good quality/size tradeoffDoes not fit: needs 74.7 GB
85.3 GB87.3 GB6-bit, very good — 6-bit quantization, very good qualityDoes not fit: needs 86.3 GB
103.3 GB105.3 GB8-bit, near-lossless — 8-bit quantization, near-losslessDoes not fit: needs 104.3 GB
est.calculated, no published file yet

Selected Q4_K_M

4-bit medium quantization

63.1GBat 16K context

Weights
61.7 GB
KV cache
1.1 GB
Overhead
0.3 GB

Doesn't fit RTX 4090 (reference) · needs 39.1 GB more

≥50 tok/s needs ≥313 GB/s · M3 Ultra ~78, M2 Ultra ~77

Or .

Which Hardware Can Run Ling Flash 2.0?

Q4_K_M · 62.2 GB

Ling Flash 2.0 (Q4_K_M) requires 62.2 GB of VRAM to load the model weights. For comfortable inference with headroom for KV cache and system overhead, 81+ GB is recommended. Using the full 33K context window can add up to 2.0 GB, bringing total usage to 64.2 GB. No consumer GPU has enough memory. 31 devices with unified memory can run Ling Flash 2.0, including Mac Studio (M3 Ultra, 256GB), Mac Studio (M3 Ultra, 512GB), Mac Studio (M3 Ultra, 96GB).

By VRAM tier · typical GPUs and Macs at Q4_K_M
8–16 GB · RTX 4060, RTX 3060 12GB, RTX 5060 Ti 16GBDoesn't fit — smallest quant needs 29.7 GB8 GB tier →12 GB tier →16 GB tier →
24 GB · RTX 4090referenceDoesn't fit — smallest quant needs 29.7 GB24 GB tier →
Mac 32 GB · Mac Mini M4Doesn't fit — smallest quant needs 29.7 GBMacs →
Mac 64 GB · Mac Studio M4 MaxQ4_K_S · 59.3 GB · ~64 tok/s · 32KMacs →

How good is Ling Flash 2.0?

llmrun Score blends public benchmark boards into one number; 100 = the average open model.

Not enough data yet for an llmrun Score.

A Score needs results on enough independent boards. How the Composite Score is built

Benchmarks

This is the single board showing results for this model; badges show who ran the test.

Alternatives to Ling Flash 2.0

Similar models

5
ModelScoreVRAMtok/sWhy it is similar
Llama 4 Scout 17B 16E InstructMeta82.177 GB—needs > 24 GBsame size
C4ai Command A 03 2025Cohere79.878.7 GB—needs > 24 GBsame size
GLM 4.6VZ.ai—66 GB—needs > 24 GBsame size
C4ai Command R Plus 08 2024Cohere—73.8 GB—needs > 24 GBsame size
Solar Open 100BUpstage—63.5 GB—needs > 24 GBsame size

Specifications

Publisher
Inclusion AI
Parameters
102.9B
Active parameters
6.2B per token
Architecture
BailingMoeV2ForCausalLM
Context Length
32,768 tokens
Vocabulary Size
157,184
Release Date
2025-09-17
License
MIT

Frequently Asked Questions

How much VRAM does Ling Flash 2.0 need?

Ling Flash 2.0 requires 62.2 GB of VRAM at Q4_K_M, or 206.2 GB at BF16. Full 33K context adds up to 2.0 GB (64.2 GB total).

VRAM = Weights + KV Cache + Overhead

Weights = 102.9B × 4.8 bits ÷ 8 = 61.7 GB

KV Cache + Overhead ≈ 0.5 GB (at 2K context + ~0.3 GB framework)

Fit ratings and hardware model lists check this model with room for a 16K-token context, which needs a little more memory.

KV Cache + Overhead ≈ 2.5 GB (at full 33K context)

VRAM usage by quantization

62.2 GB
64.2 GB

Learn more about VRAM estimation →

Can NVIDIA GeForce RTX 5090 run Ling Flash 2.0?

Yes, at IQ2_XS (31.3 GB) or lower. Higher quantizations like IQ2_S (32.6 GB) exceed the NVIDIA GeForce RTX 5090's 32 GB.

What's the best quantization for Ling Flash 2.0?

For Ling Flash 2.0, Q4_K_M (62.2 GB) offers the best balance of quality and VRAM usage. Q4_K_L (63.5 GB) provides better quality if you have the VRAM. The smallest option is IQ2_XXS at 28.7 GB.

VRAM requirement by quantization

IQ2_XXS
28.7 GB
IQ3_XS
42.9 GB
Q4_0
51.9 GB
Q4_K_M ★
62.2 GB
Q4_K_L
63.5 GB
BF16
206.2 GB

★ Recommended — best balance of quality and VRAM usage.

Learn more about quantization →

Can I run Ling Flash 2.0 on a Mac?

Yes — Mac Studio M5 Max (36 GB) and 65 other Macs can run Ling Flash 2.0, the smallest at IQ2_XS. Apple Silicon uses unified memory, so the model shares RAM with the system. At Q4_K_M you need at least 62.2 GB of usable unified memory (RAM minus macOS overhead), from Mac Studio (M3 Ultra, 96GB).

Can I run Ling Flash 2.0 locally?

Yes — Ling Flash 2.0 can run locally on consumer hardware. Popular tools include Ollama, LM Studio, and llama.cpp.

How fast is Ling Flash 2.0?

At Q4_K_M, Ling Flash 2.0 can reach ~139 tok/s on AMD Instinct MI350X. Speed depends mainly on GPU memory bandwidth. Real-world results typically within ±20%.

tok/s = 1000 ÷ (active GB ÷ (bandwidth GB/s × efficiency) × 1000 + layers × routing ms)

Mixture-of-Experts: just the active experts get read for each token, along with a fixed routing cost per layer.

Example: NVIDIA B200 → 3.7 GB active ÷ (8000 × 0.65) = 0.715 ms, plus 32 layers × 0.055 ms = 1.760 ms, so 1000 ÷ 2.475 ms = ~404 tok/s

Estimated speed at Q4_K_M (62.2 GB)

~404 tok/s
~404 tok/s
~342 tok/s

Real-world results typically within ±20%. Speed depends on batch size, quantization kernel, and software stack.

Learn more about tok/s estimation →

What's the download size of Ling Flash 2.0?

At Q4_K_M, the download is about 61.73 GB. The full-precision BF16 version is 205.78 GB. The smallest option (IQ2_XXS) is 28.29 GB.

Which GPUs can run Ling Flash 2.0?

No single consumer GPU has enough VRAM to run Ling Flash 2.0 at Q4_K_M (62.2 GB). Multi-GPU or professional hardware is required.

Which devices can run Ling Flash 2.0?

31 devices with unified memory can run Ling Flash 2.0 at Q4_K_M (62.2 GB), including ASUS Ascent GX10, Beelink GTR9 Pro (Ryzen AI Max+ 395, 128 GB), Framework Desktop (Ryzen AI Max+ 395, 128 GB), GMKtec EVO-X2 (Ryzen AI Max+ 395, 128 GB). Apple Silicon Macs use unified memory shared between CPU and GPU, making them well-suited for local LLM inference.