Luth-2: Pushing the French Capabilities of SLMs with MOPD

Maxence Lasbordes

MaxLSB

Follow

Guillaume Pradel

jddqd

Follow

Introduction

We introduce Luth-2-0.8B and Luth-2-2B, two models that set a new state of the art in French for their size across math, code, instruction following, general knowledge and tool calling. They are non-reasoning models post-trained from the Qwen3.5 family in French.

Luth-2 builds on our previous work, Luth, with several substantial improvements. Our new SFT mixture, Luth-2-Post-Training-SFT, has grown to 3B tokens and covers a broader range of domains, including mathematics, knowledge, code, tool calling, instruction following, multi-turn dialogue, and science. Unlike the first iteration, Luth-2 also incorporates reinforcement learning and multi-domain on-policy distillation (MOPD) (NVIDIA, 2026) to further extend the models' French capabilities. Finally, we move to Qwen3.5, whose French performance is comparable to Qwen3's but which we found to be substantially more receptive to post-training.

The resulting models outperform every model in their size class across the selected benchmarks, while staying competitive with models two to three times their size. Both are light enough to run locally, for on-device use. More broadly, these results suggest that current multilingual SLMs still leave substantial capability on the table outside English, even for high-resource languages like French. We release the models, data, code and recipe used.

• 🤖 Models: Luth-2-2B | Luth-2-0.8B
• 📚 Datasets: Luth-2-Post-Training-SFT | Luth-2-Post-Training-RL
• 💻 Code: GitHub
• 🏆 Leaderboard: Leaderboard

Evaluation

For this release we deliberately widened the evaluation set using a fork of lm-evaluation-harness. All French benchmarks are either official French subsets or translations we verified ourselves. Some scores differ slightly from our last release, because of prompt changes and parsing improvements.

The new benchmarks and evaluation changes worth calling out:

• Math. We use MGSM-Rev2 (Peter et al., 2025), a corrected version of MGSM (Shi et al., 2022), with the more robust parsing and output normalisation the paper prescribes for French. On every other math benchmark we parse the answer from \boxed{} and normalise it with that same method before comparing it to the ground truth. For instance, French tends to use a comma as the decimal separator, so 27,00 is normalised to 27 rather than incorrectly parsed as 2700.
• Knowledge and science. We use the French subsets of the standard multilingual MCQ benchmarks: Global-MMLU-Lite (Singh et al., 2024), a lighter, human-annotated version of MMLU, and MMLU-ProX-Lite (Xuan et al., 2025). For GPQA-Diamond (Rein et al., 2023) we use a translated version. Unlike last time we score them in generation mode, parsing the answer from \boxed{} instead of using a log-probability metric.
• Code. French translations of HumanEval+ and MBPP+ (Liu et al., 2023), translated with Opus 4.8 and manually verified, scored by parsing the Python block out of the model's markdown.
• Instruction following. We use the French version of IFEval in M-IFEval (Dussolle et al., 2025) with French-specific verifiable constraints, plus the French subset of Multi-IF (He et al., 2024) for multi-turn instruction following.
• Tool calling. We adapted BFCL (Patil et al., 2025) to French, v1 and v2 subsets only, translating with Opus 4.8 and verifying a subset of the samples by hand.
• For code and tool calling we translate prose only: function names, parameter names and tool schemas stay in English.

All numbers are obtained with temperature=0.6, top_p=0.95, top_k=20, thinking disabled, and averaged over 10 runs. For IFEval we report prompt-level strict accuracy; for Multi-IF, the final-turn composite.

French Benchmark Results

We report per-benchmark scores for our models alongside several of the strongest open-source contenders of comparable size. Luth-2-0.8B substantially outperforms Luth-0.6B-Instruct and ranks first among all tested models in its size class on each of the 12 benchmarks. It is surpassed only by larger models: Gemma-3-1B-IT on MBPP+ and LFM2.5-1.2B-Instruct on five benchmarks, which have approximately ~33% and ~56% more parameters, respectively. Luth-2-2B follows the same pattern, outperforming Luth-1.7B-Instruct on 11 of the 12 benchmarks and ranking first overall on 10, surpassed only by the larger LFM2-2.6B on Global-MMLU-Lite and by Luth-1.7B-Instruct on BFCL v2.

All evaluation results can be reproduced using our evaluation setup, available on our GitHub.

Note: All models were evaluated in non-reasoning mode.

Supervised fine-tuning

We scaled the data (Luth-2-Post-Training-SFT) to ~3B tokens across five main domains. Following our first data generation setup, we translated the prompts of several English datasets (nvidia/Nemotron-Post-Training-Dataset-v2, allenai/Dolci-Instruct-SFT, allenai/Dolci-Instruct-SFT-Tool-Use, HuggingFaceTB/smoltalk2, etc.) to French and regenerated the answers with strong teachers: Qwen/Qwen3.6-35B-A3B, google/gemma-4-31B-it, Qwen/Qwen3-30B-A3B and google/gemma-4-26b-a4b-it. Each domain's recipe was tuned in isolation against its own benchmarks, then the domains were combined and deduplicated globally.

Decontamination. Our dataset is decontaminated against all evaluation benchmarks with 8-gram token overlap, following the Tülu 3 method (Lambert et al., 2025): a training sample is dropped when more than 50% of any benchmark item's 8-grams appear in it.

Using TRL, we run full fine-tuning on top of Qwen3.5-0.8B and Qwen3.5-2B for 1 epoch over the mixture, with FlashAttention-3, sequence packing, max_seq_length=16384, lr=3.0e-5 on a cosine schedule and a global batch size of ~500K tokens.

Both SFT checkpoints already come out ahead of the previous Luth models, and of every other model in their size class. We then move to the MOPD stage to push their capabilities further.

Multi-Domain On-Policy Distillation

Recent releases have shown strong results with reinforcement learning from verifiable rewards, but running RL over mixed domains tends to trade one capability off against another. Multi-domain on-policy distillation (MOPD) (NVIDIA, 2026) avoids that: train one specialist per domain with RL from the same base model, then distil all of them back into a single student. Training them separately lets each specialist optimise deeply for its own domain, with targeted data and its own reward, free of competing updates from unrelated objectives.

Using prime-rl and our RL dataset Luth-2-Post-Training-RL, we trained three specialists: math, code and instruction following, then distilled them into the final model with MOPD.

RL specialists

Every specialist uses the same recipe: GRPO (Shao et al., 2024) with DAPO's zero-variance group filter (Yu et al., 2025), so each step trains on something, for 500 steps, 32 prompts × 8 rollouts, lr=1e-6, temperature 1.0 and max off-policy steps at 2.

Math. For Luth-2-2B we translated the prompts of BytedTsinghua-SIA/DAPO-Math-17k (Yu et al., 2025), with a binary reward on the \boxed{} answer verified against the gold. For Luth-2-0.8B we used open-r1/Big-Math-RL-Verified-Processed (Albalak et al., 2025) instead, as DAPO-Math is too hard for a non-reasoning model of that size.

Code. We translated prompts from nvidia/OpenCodeInstruct (Ahmad et al., 2025), with a binary reward: the dataset's unit tests run in a sandboxed subprocess and the rollout scores 1 only if all of them pass.

Instruction following. We take chat prompts from our SFT data and append French IFEval constraints. To push generalisation we broaden that pool: 12 out-of-domain constraint types on top of the 30 IFEval-fr ones, wider value ranges for each constraint, and 1 to 5 constraints stacked per prompt rather than a single one. We train on single-turn and multi-turn prompts: the multi-turn ones are 2 to 3 turn conversations where each new turn adds a constraint and all the earlier ones must still hold.

Rewarding the constraint-satisfaction rate alone was heavily reward-hacked: the model learned to emit very short, sometimes broken French that satisfied the constraints without answering the question at all. Following IFBench (Pyatkin et al., 2025), we blend a quality signal into the reward:

R = V + 1.0    if V > 0 and S > α
    V − 0.5    if V > 0 and S ≤ α
    V          if V ≤ 0

with V the dense constraint-satisfaction rate and S a 1–10 French-quality score from a Qwen3.5-9B judge that only sees the task, never our appended constraints (gate α = 7).

Decontamination. Every RL prompt is also decontaminated against all evaluation benchmarks with 8-gram token overlap.

Distillation

For the final distillation step, we use the SFT model as student and our 3 RL specialists as Teacher and reuse the same RL prompts we used to train the specialists. We use a distribution of 1/3 of the prompts per domain and perform 100 steps of MOPD to get our final model.

The student samples the rollouts and its domain's teacher scores them, the loss being the per-token reverse KL to the teacher. That dense signal is far more gradient-efficient than a sparse reward, which is why 100 steps suffice where the specialists needed 500. We sample 128 prompts × 4 rollouts per step, max off-policy steps at 2, and raise the learning rate to 2e-6 with a 20-step warmup.

The distilled model keeps nearly all of each specialist's gain, and carries knowledge, science and tool calling over from the SFT checkpoint with slight improvements.

Acknowledgement

We thank LightOn for providing the compute used to train the models.

Citation

@misc{luth2,
  title  = {Luth-2: Pushing the French Capabilities of SLMs with MOPD},
  author = {Maxence Lasbordes and Guillaume Pradel},
  year   = {2026},
  url    = {https://huggingface.co/blog/MaxLSB/luth-2}
}

References

• Peter et al. (2025). Mind the Gap… or Not? How Translation Errors and Evaluation Details Skew Multilingual Results. arXiv:2511.05162
• Shi et al. (2022). Language Models are Multilingual Chain-of-Thought Reasoners. arXiv:2210.03057
• Singh et al. (2024). Global MMLU: Understanding and Addressing Cultural and Linguistic Biases in Multilingual Evaluation. arXiv:2412.03304
• Xuan et al. (2025). MMLU-ProX: A Multilingual Benchmark for Advanced Large Language Model Evaluation. arXiv:2503.10497
• Rein et al. (2023). GPQA: A Graduate-Level Google-Proof Q&A Benchmark. arXiv:2311.12022
• Liu et al. (2023). Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation. arXiv:2305.01210
• Dussolle et al. (2025). M-IFEval: Multilingual Instruction-Following Evaluation. arXiv:2502.04688
• He et al. (2024). Multi-IF: Benchmarking LLMs on Multi-Turn and Multilingual Instructions Following. arXiv:2410.15553
• Patil et al. (2025). The Berkeley Function Calling Leaderboard (BFCL): From Tool Use to Agentic Evaluation of Large Language Models. ICML 2025
• Lambert et al. (2025). Tülu 3: Pushing Frontiers in Open Language Model Post-Training. arXiv:2411.15124
• NVIDIA (2026). Nemotron-Cascade 2. arXiv:2603.19220
• Shao et al. (2024). DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models. arXiv:2402.03300
• Yu et al. (2025). DAPO: An Open-Source LLM Reinforcement Learning System at Scale. arXiv:2503.14476
• Albalak et al. (2025). Big-Math: A Large-Scale, High-Quality Math Dataset for Reinforcement Learning in Language Models. arXiv:2502.17387
• Ahmad et al. (2025). OpenCodeInstruct: A Large-scale Instruction Tuning Dataset for Code LLMs. arXiv:2504.04030
• Pyatkin et al. (2025). IFBench: Generalizing Verifiable Instruction Following. arXiv:2507.02833