# Rust nightly active son frontend parallèle par défaut

_Publié le 16 novembre 2026 — https://ip73.fr/2026/11/16/rust-nightly-active-son-frontend-parallele-par-defaut/_

Depuis le 14 novembre, les builds nightly du compilateur Rust font tourner par défaut leur frontend en parallèle, avec deux threads. L'équipe Rust l'a annoncé le 16 novembre sur son blog : le but est de débusquer les derniers défauts avant une stabilisation, initialement prévue pour 2024 et jamais concrétisée.

## Ce qui change dans rustc nightly

Jusqu'ici, seule la partie « backend » du compilateur, celle qui passe par LLVM, exploitait plusieurs cœurs. Le frontend, qui englobe la vérification des types et le borrow checker, s'exécutait sur un seul thread. Le support du parallélisme y existait pourtant depuis longtemps, mais restait optionnel à cause de problèmes non résolus. Il était activable sur nightly depuis trois ans, avec l'objectif affiché de le stabiliser en 2024. L'équipe reconnaît elle-même que ce calendrier n'a pas été tenu.

Le chantier, qui avançait lentement, s'est accéléré l'an dernier avec un effort coordonné lancé par Vadim Petrochenkov et plusieurs autres contributeurs. De nombreux bugs anciens ont été corrigés et les performances améliorées, selon le blog de Rust. Phoronix relève de son côté que le frontend « s'exécutait de façon séquentielle par défaut » jusqu'à présent, et que l'activation vise à élargir les tests avant la stabilisation.

Le réglage de départ est volontairement prudent : deux threads seulement, pour limiter la hausse de consommation mémoire tout en laissant remonter les éventuels défauts.

## Des gains réels, mais très inégaux

Les chiffres de l'équipe portent sur la compilation d'une seule crate, la dernière d'un graphe de dépendances, comparée à la même compilation avec un frontend séquentiel. Variation moyenne du temps réel, sur les projets « réels » de la suite de benchmarks :

| Threads frontend | check | clippy | debug | opt |
|---|---|---|---|---|
| 2 | -21,95 % | -20,74 % | -14,2 % | -12,51 % |
| 4 | -37,99 % | -36,01 % | -29,14 % | -23,67 % |
| 8 | -44,23 % | -41,76 % | -36,1 % | -27,88 % |

Le profil `check` en profite le plus, le profil `opt` le moins. Pour certaines crates (nalgebra, cargo, diesel), un `cargo check` avec huit threads est presque trois fois plus rapide. Dans d'autres benchmarks, le parallélisme n'aide guère, précise l'équipe, qui reconnaît que la parallélisation reste imparfaite et compte y consacrer davantage d'efforts.

Les recompilations incrémentales, elles, gagnent peu : 3 à 5 % en moyenne dans la suite de tests. Rust prévient que ces mesures sont difficiles à comparer, car le résultat dépend de ce qui a été modifié et de la répartition des unités de génération de code. Il reconnaît aussi manquer de bons benchmarks pour ce cas d'usage. Autre curiosité : activer le frontend parallèle peut accélérer le backend.

### Sur un vrai projet, l'effet fond

Ces mesures valent pour une crate isolée. Dans un projet complet, les cœurs sont souvent déjà occupés par LLVM ou par Cargo qui compile plusieurs crates à la fois. Le test de bout en bout de `cargo check` sur la crate cargo elle-même, sur une machine à huit cœurs, le montre bien :

| Threads frontend | Durée |
|---|---|
| 1 | 36,7 s |
| 2 | 35,1 s |
| 4 | 31,9 s |
| 8 | 30,8 s |

Soit environ 15 % de mieux avec huit threads, loin du facteur trois des meilleurs cas. Les développeurs qui compilent de gros espaces de travail sur une machine modeste ne doivent donc pas s'attendre à des miracles. Ceux qui travaillent sur une crate volumineuse avec des cœurs disponibles ont plus à y gagner.

## Tester d'autres réglages

Le nombre de threads se règle avec l'option `--jobs-frontend`, soit dans la variable d'environnement `RUSTFLAGS`, soit dans le fichier `.cargo/config.toml` :

```toml
[build]
rustflags = ["-Zunstable-options", "--jobs-frontend=8"]
```

Rust indique que le passage à l'échelle devrait se dégrader au-delà d'environ huit threads, tout en invitant à essayer sur sa propre charge. Plus de threads signifie aussi plus de mémoire, au point, dans les cas extrêmes, de faire tomber la machine à court de RAM. Un point à surveiller sur les runners de CI aux ressources comptées.

Pour revenir en arrière, en revanche, le blog de Rust ne décrit aucune procédure. Ses mesures sur cargo prennent bien une exécution à un seul thread comme point de départ, mais rien n'indique qu'un `--jobs-frontend=1` équivaille exactement à l'ancien frontend séquentiel.

## Limites connues et suite des travaux

Le parallélisme a un coût de prévisibilité. L'ordre des diagnostics, c'est-à-dire des messages d'erreur et d'avertissement, peut ne plus être déterministe. Plus délicat pour les équipes attachées aux builds reproductibles : dans certaines situations, le binaire produit peut différer d'une compilation à l'autre. L'équipe range ces cas parmi les bugs à identifier et à corriger. L'équipe signale en outre des problèmes déjà connus de reproductibilité du compilateur lorsque le frontend parallèle est activé.

Le travail se poursuit aussi dans le code. Une pull request sur le dépôt rust-lang/rust, signée aerooneqq, parallélise la phase de transformation de l'AST en HIR. Ses deux essais de performance, passés par le bot de rustc-perf, restent mitigés : le premier conclut à des régressions, le second à un mélange de régressions et d'améliorations. Le temps de bootstrap du compilateur y bouge à peine, +0,33 % puis -0,27 %. Dans les deux cas, le bot a classé la PR comme sensible aux performances, ce qui oblige à justifier les régressions ou à les corriger avant toute intégration.

Le dépôt rustc-perf, justement, réunit l'outil qui collecte les mesures de performance pour chaque commit intégré par bors et le site qui les affiche, avec ce bot de benchmark à la demande.

Reste la vraie question : la date. Rust promet une stabilisation dès que l'équipe sera assez sûre de son fonctionnement, sans avancer de calendrier. Les retours des utilisateurs de nightly dans les semaines qui viennent diront si l'échéance est cette fois réaliste.

## Sources

- [GitHub - rust-lang/rustc-perf: Website for graphing performance of rustc](https://github.com/rust-lang/rustc-perf), github.com
- [Parallelize AST -> HIR lowering by aerooneqq · Pull Request #163495 · rust-lang/rust](https://github.com/rust-lang/rust/pull/163495), github.com
- [Enabling the parallel frontend on nightly](https://blog.rust-lang.org/2026/11/16/enabling-parallel-frontend-on-nightly/), Rust, 16 novembre 2026
- [Rust Nightly To Begin Enabling Parallel Frontend By Default](https://www.phoronix.com/news/Rust-Nightly-Parallel-Frontend), Phoronix, 16 novembre 2026
