Today, we are excited to announce the open-sourcing of Ling 2.0 — a family of MoE-based large language models that combine SOTA performance with high efficiency.
The first released version, Ling-mini-2.0, is compact yet powerful. It has 16B total parameters, but only 1.4B are activated per input token (non-embedding 789M). Trained on more than 20T tokens of high-quality data and enhanced through multi-stage supervised fine-tuning and reinforcement learning, Ling-mini-2.0 achieves remarkable improvements in complex reasoning and instruction following. With just 1.4B activated parameters, it still reaches the top-tier level of sub-10B dense LLMs and even matches or surpasses much larger MoE models.
Strong General and Professional Reasoning
We evaluated Ling-mini-2.0 on challenging general reasoning tasks in coding (LiveCodeBench, CodeForces) and mathematics (AIME 2025, HMMT 2025), as well as knowledge-intensive reasoning tasks across multiple domains (MMLU-Pro, Humanity's Last Exam). Compared with sub-10B dense models (e.g., Qwen3-4B-instruct-2507, Qwen3-8B-nothinking) and larger-scale MoE models (Ernie-4.5-21B-A3B-PT, GPT-OSS-20B/low), Ling-mini-2.0 demonstrated outstanding overall reasoning capabilities.
7× Equivalent Dense Performance Leverage
Guided by Ling Scaling Laws, Ling 2.0 adopts a 1/32 activation ratio MoE architecture, with empirically optimized design choices in expert granularity, shared expert ratio, attention ratio, aux-loss free + sigmoid routing strategy, MTP loss, QK-Norm, half RoPE, and more. This enables small-activation MoE models to achieve over 7× equivalent dense performance. In other words, Ling-mini-2.0 with only 1.4B activated parameters (non-embedding 789M) can deliver performance equivalent to a 7–8B dense model.
High-speed Generation at 300+ token/s
The highly sparse small-activation MoE architecture also delivers significant training and inference efficiency. In simple QA scenarios (within 2000 tokens), Ling-mini-2.0 generates at 300+ token/s (on H20 deployment) — more than 2× faster than an 8B dense model. Ling-mini-2.0 is able to handle 128K context length with YaRN, as sequence length increases, the relative speedup can reach over 7×.
Open-sourced FP8 Efficient Training Solution
Ling 2.0 employs FP8 mixed-precision training throughout. Compared with BF16, experiments with over 1T training tokens show nearly identical loss curves and downstream benchmark performance. To support the community in efficient continued pretraining and fine-tuning under limited compute, we are also open-sourcing our FP8 training solution. Based on tile/blockwise FP8 scaling, it further introduces FP8 optimizer, FP8 on-demand transpose weight, and FP8 padding routing map for extreme memory optimization. On 8/16/32 80G GPUs, compared with LLaMA 3.1 8B and Qwen3 8B, Ling-mini-2.0 achieved 30–60% throughput gains with MTP enabled, and 90–120% throughput gains with MTP disabled.
A More Open Opensource Strategy
We believe Ling-mini-2.0 is an ideal starting point for MoE research. For the first time at this scale, it integrates 1/32 sparsity, MTP layers, and FP8 training — achieving both strong effectiveness and efficient training/inference performance, making it a prime candidate for the small-size LLM segment.
To further foster community research, in addition to releasing the post-trained version, we are also open-sourcing five pretraining checkpoints: the pre-finetuning Ling-mini-2.0-base, along with four base models trained on 5T, 10T, 15T, and 20T tokens, enabling deeper research and broader applications.
Model Downloads
You can download the following table to see the various stage of Ling-mini-2.0 models(1.43B activated of 16.26B total params). If you are located in mainland China, we also provide the model on ModelScope.cn to speed up the download process.
Note: If you are interested in previous version, please visit the past model collections in Huggingface or ModelScope.
Quickstart
🚀 Try Online
You can experience Ling-mini-2.0 online at: ZenMux
🔌 API Usage
You can also use Ling-mini-2.0 through API calls:
python
1from openai import OpenAI
23# 1. Initialize the OpenAI client4client = OpenAI(5# 2. Point the base URL to the ZenMux endpoint6 base_url="https://zenmux.ai/api/v1",7# 3. Replace with the API Key from your ZenMux user console8 api_key="<your ZENMUX_API_KEY>",9)1011# 4. Make a request12completion = client.chat.completions.create(13# 5. Specify the model to use in the format "provider/model-name"14 model="inclusionai/ling-mini-2.0",15 messages=[16{17"role":"user",18"content":"What is the meaning of life?"19}20]21)2223print(completion.choices[0].message.content)
Convert to safetensors
Models with safetensors format can be downloaded from HuggingFace or ModelScope.
If you want to train your model and eval it, you can convert from dcp produced by training.
1from transformers import AutoTokenizer
2from vllm import LLM, SamplingParams
3tokenizer = AutoTokenizer.from_pretrained("inclusionAI/Ling-mini-2.0")4sampling_params = SamplingParams(temperature=0.7, top_p=0.8, repetition_penalty=1.05, max_tokens=16384)5llm = LLM(model="inclusionAI/Ling-mini-2.0", dtype='bfloat16')6prompt ="Give me a short introduction to large language models."7messages =[8{"role":"system", "content":"You are Ling, an assistant created by inclusionAI"},
9{"role":"user", "content": prompt}10]11text = tokenizer.apply_chat_template(12 messages,
13tokenize=False,
14add_generation_prompt=True
15)16outputs = llm.generate([text], sampling_params)
Then you should apply patch to sglang installation:
shell
1# patch command is needed, run `yum install -y patch` if needed2patch -d `python -c 'import sglang;import os; print(os.path.dirname(sglang.__file__))'` -p3 < inference/sglang/bailing_moe_v2.patch
Run Inference
BF16 and FP8 models are supported by SGLang now, it depends on the dtype of the model in ${MODEL_PATH}. They both share the same command in the following:
MTP is supported for base model, and not yet for chat model. You can add parameter --speculative-algorithm NEXTN
to start command.
Client:
shell
1curl -s http://localhost:${PORT}/v1/chat/completions \2 -H "Content-Type: application/json"\3 -d '{"model": "auto", "messages": [{"role": "user", "content": "What is the capital of France?"}]}'4"""
We also provide a complete and efficient training framework that covers both pre-training and finetune. Based on this framework, continue training can be performed on the Ling-mini-2.0 checkpoint. With our training framework, the training throughput of the Ling-mini-2.0 model is significantly better than that of the existing Dense 8B model (Qwen3-8B, Llama3-8B).
The table below shows the pre-training performance of several models, measured in tokens per second on 8, 16, and 32 80G GPUs. Ling-mini-2.0 achieves significantly higher training efficiency compared to the baseline, making it easier and more cost-effective to continue pre-training with our demo scripts.
