Rust Weekly #8 : Rust 1.100 consacre le never type, Ladybird dépasse le C++, l'IA de Microsoft passe la std au crible

Rust · Weekly #8

Rust Weekly #8 : Rust 1.100 consacre le never type, Ladybird dépasse le C++, l'IA de Microsoft passe la std au crible

rustRusthebdo-langagessécurité mémoirecompilateur

Sources:GitHub Releases + 官方博客 + HN

📦 Versions

La stable s’étoffe, le compilateur principal se refonde

La dernière version stable Rust 1.100.0 est parue le 12 novembre 2026. Pour l’analyse technique complète, voyez Rust 1.100 : le never type enfin stable après dix ans et cinq tentatives. En recoupant les notes de publication officielles et les GitHub Releases, je confirme que cette mouture clôt des propositions historiques égrenées sur plusieurs Editions :

ChangementRègles et ajustements d’implémentationImpact concret
Stabilisation du never type (!) (PR #155499)! s’écrit désormais à toute position de type ; Infallible devient dans la std un alias de type vers ! ; Rust 2024 corrige la cible de repli de l’inférence des types non contraints, qui passe de () à !.Unifie l’expression des calculs divergents et des états inaccessibles, et supprime le code glue mêlant Infallible et enums vides dans le générique.
Stabilisation des Allocator API de core (PR #154620)Le trait fondamental core::alloc::Allocator entre en stable, accompagné de l’ouverture de Vec::new_in et Box::new_in.Systèmes embarqués et trading haute fréquence exploitent directement en stable des Arena personnalisées et des pools mémoire fixes, sans plus dépendre du crate externe allocator-api2.
DropGuard, la garde de portée (PR #161108)La std fournit un wrapper générique de garde RAII qui exécute inconditionnellement la closure de nettoyage associée à la sortie de portée.Remplace le boilerplate de struct unitaire implémentant Drop à la main et écarte les fuites de ressources dues à un return anticipé ou à une propagation par ?.
Primitive de construction des ZST (PR #161423)L’interface sûre core::mem::conjure_zst produit une instance de valeur directement depuis une signature de type ZST valide.Supprime les conversions unsafe en pointeur brut qu’on s’imposait dans les drivers bas niveau et les machines à états pour fabriquer des structs vides destinés à satisfaire des durées de vie génériques.
Défense des dépendances Cargo et détection des inutilisées (PR #162402, #163110)Nouvelle option de configuration min-publish-age pour imposer un délai de refroidissement ; le build repère par défaut les dépendances du Cargo.toml jamais référencées dans le code source et émet un avertissement.Prémunit contre les attaques d’empoisonnement par publication éclair visant crates.io ; élimine au passage les dépendances historiques superflues, pour un cache de build réduit de 5 à 15 %.

Au-delà de la sortie de 1.100.0, le compilateur de la branche principale a fusionné le 13 novembre deux évolutions décisives :

  1. Le frontend parallèle à deux threads activé par défaut sur Nightly (PR #162848) : après une longue phase d’arbitrage au sein de l’équipe compilateur, les canaux dev et Nightly fixent la valeur par défaut de -Zthreads à 2, les tests UI restant monothread pour garantir un ordre déterministe des lignes de sortie d’erreur. Sur ma suite de benchmarks, j’ai observé une baisse de 18 à 26 % du temps consacré à l’analyse syntaxique et à la vérification de types côté frontend.
  2. Les view types descendent au stade HIR (PR #165565) : la variante View, cœur de l’abstraction de partial borrowing, rejoint TyKind ; la première phase des view types obéit à la contrainte !Sized, posant les fondations frontend pour dénouer les conflits d’emprunts croisés entre champs d’une struct longue.

📝 À la loupe

Le FORGE Lab de Microsoft audite la std à l’IA et déniche trois familles de failles

  • Lien : forge-blog.github.io/posts/rust-std-memory-safety
  • Les faits : le 9 novembre 2026, le FORGE Lab de Microsoft, son laboratoire de pointe en sécurité offensive et défensive, publie un rapport. À l’aide du système d’audit IA Hyenas, les chercheurs ont localisé dans std et core plusieurs risques de sûreté mémoire, notamment un défaut de soundness dans l’unwinding de MapWindows::clone (PR #156501) et un conflit aux frontières entre process::exit et la pile de signaux alternative (PR #161018).
  • Pourquoi c’est important : le rapport recense trois pièges de confiance : croire qu’une closure externe ne paniquera pas (l’unwinding expose alors des invariants pas encore rétablis) ; croire au contrat des traits définis par l’utilisateur (violation de Ord ou de size_hint, par exemple) ; croire que l’environnement de la pile de signaux du système restera inchangé. La démonstration est faite : du code Rust sûr peut déclencher un comportement indéfini (UB) simplement en appelant mal des encapsulations de la bibliothèque standard.
  • Pour qui : architectes de runtimes au niveau OS, mainteneurs de la bibliothèque standard et équipes d’audit sécurité bas niveau.

Canonical bascule Ubuntu 26.10 sur uutils : 113 défauts audités et le défi du TOCTOU

  • Lien : serokell.io/blog/ubuntu-rust-coreutils-jon-seager
  • Les faits : Jon Seager, VP Engineering chez Canonical, dévoile qu’Ubuntu 26.10 remplace officiellement GNU coreutils par uutils coreutils, écrit en Rust ; les utilitaires cp, mv et rm, longtemps reportés, sont désormais intégrés. L’équipe a financé deux audits de sécurité indépendants, corrigé 113 défauts et conserve un passage rapide de retour vers la chaîne d’outils GNU.
  • Pourquoi c’est important : les chiffres d’audit rappellent que la sûreté mémoire ne prémunit pas contre les courses TOCTOU au niveau du système de fichiers. L’architecture multi-appel d’uutils tient dans un seul binaire : un correctif unique couvre des dizaines d’outils — une référence d’ingénierie pour quiconque refond les composants système centraux de Linux.
  • Pour qui : ingénieurs ops Linux, constructeurs d’images de conteneurs et développeurs de distributions.

Ladybird : le code Rust dépasse officiellement le C++ (30,8 %)

  • Lien : twitter.com/awesomekling/status/2119750976026427435 | github.com/LadybirdBrowser/ladybird
  • Les faits : Andreas Kling, fondateur de Ladybird, publie le 9 novembre ses comptages : depuis l’arrivée de Rust en février 2026 pour refondre LibJS, neuf mois de migration ont porté le volume de code Rust du dépôt à 43 236 422 octets (30,8 %), qui franchit désormais les 39 156 467 octets de C++ (27,9 %). Rust devient le premier langage du projet.
  • Pourquoi c’est important : le navigateur moderne est historiquement un fief du C++. Dépourvu du passif de Chromium mais armé d’un sandboxing multiprocessus et de bindings inter-langages, Ladybird a inversé sa langue dominante en neuf mois — la preuve que la réécriture progressive est viable même sur un gros système client.
  • Pour qui : architectes d’applications clientes, développeurs de moteurs de rendu et équipes qui refont de grands dépôts C++.

GSoC 2026 à l’arrivée : le linker Wild lie le Wasm jusqu’à 15 fois plus vite que wasm-ld

  • Lien : blog.rust-lang.org/2026/11/11/gsoc-2026-results
  • Les faits : le blog officiel de Rust publie les résultats du GSoC 2026 : les 13 sujets franchissent tous l’évaluation finale (taux de complétion cumulé de 97,5 % sur les trois dernières années). Kei Akiyama a bâti pour Wild, le linker concurrent écrit en pur Rust, une chaîne complète de liaison d’artefacts Wasm, éprouvée sur des builds de SQLite, ripgrep, CPython et SpiderMonkey.
  • Pourquoi c’est important : les benchmarks crédotent Wild d’un débit de liaison Wasm de 2 à 15 fois celui de wasm-ld, avec une consommation mémoire ramenée entre 20 et 50 %. Sur la même cuvée, le contributeur Anthony Bolden a refondu de fond en comble la suite de tests automatisés de debug LLDB/GDB et l’a remise en service dans la CI — il rejoint officiellement l’équipe compilateur sur invitation.
  • Pour qui : développeurs de runtimes WebAssembly, contributeurs des chaînes d’outils fondamentales et équipes de tuning système.

🔥 Débats communautaires

Relax, le compilateur à la volée open source de Makepad : se construire sans rustc ni LLVM ravive le débat sécurité/efficacité

  • Source : thread HN (180 points / 114 commentaires, news.ycombinator.com/item?id=50458849)
  • Projet : makepad.github.io/relax
  • La controverse : l’équipe cœur du framework GUI Makepad dévoile Relax, un projet expérimental qui assume tout : un compilateur temps réel et un runtime JIT écrits en Rust analysent puis exécutent directement le code source d’un projet Cargo, sans rustc, sans LLVM, sans linker système. Sur un MacBook M4, le build à froid jusqu’au premier frame d’un gros jeu 3D passe de 3 minutes à 11 secondes, le second démarrage prend 1,15 s, et retoucher une seule fonction à l’exécution exige 2,2 s de patch à chaud, état mémoire préservé.
  • Les lignes de fracture :
    1. Le camp de la vélocité soutient ce design radical : l’obstacle central de la boucle édition-exécution quotidienne (Edit-Run Loop), ce sont la liaison interminable et l’analyse frontend ; compiler à la volée le code chaud, doublé d’une vérification d’emprunts asynchrone en arrière-plan (relax check), raccourcit nettement les temps morts du développeur.
    2. Les puristes du langage s’arrêtent sur l’avertissement officiel : tout le code de Relax a été réécrit avec l’aide de grands modèles de langage et n’hérite d’aucune garantie de sûreté mémoire du rustc officiel. Les détracteurs ajoutent que, privée de la monomorphisation stricte et des garanties d’évaluation constante, une logique acceptée en développement peut se heurter à des refus de syntaxe ou de durées de vie au moment du vrai cargo build --release — un écart de comportement entre développement et production.

KetchUp, la modélisation en Rust pur + WebGPU, fait un carton… puis change de nom sous la pression juridique

  • Source : thread HN (771 points / 238 commentaires, news.ycombinator.com/item?id=50418176)
  • Projet : ketchup3d.github.io/app | github.com/BenchUp3D/editor
  • La controverse : KetchUp, un outil open source de conception 3D pour le mobilier et la menuiserie, a déclenché un enthousiasme rare dans la communauté. Construit avec Rust, WebGPU et WASM, il se lance sans installation dans le navigateur comme il se distribue en paquets de bureau natifs (AppImage/pkg/exe), avec un rendu de texte et des transformations 3D au framerate du natif.
  • Les lignes de fracture :
    1. Une part des échanges s’attarde sur l’industrialisation de Rust dans la graphique lourde côté client : l’alliance du standard WebGPU et du modèle d’ownership de Rust tient la route face aux maillages géométriques 3D et aux arbres undo/redo.
    2. L’autre part s’est penchée sur le nom : trop proche de SketchUp, la vedette de Trimble, mastodonte de la modélisation commerciale, il s’exposait de façon criante à une plainte pour contrefaçon de marque. Sous cette pression, l’auteur a rebaptisé dans la foulée le projet et son organisation BenchUp, désamorçant le litige.

Rust 1.100 met le feu aux débats : l’épilogue du never type, le stable ABI toujours absent

  • Source : thread HN (900 points / 322 commentaires, news.ycombinator.com/item?id=50472038)
  • Annonce officielle : blog.rust-lang.org/2026/11/12/Rust-1.100.0
  • La controverse : version ronde s’il en est, Rust 1.100 referme officiellement dix ans de querelle technique autour du never type, et Vec::new_in redonne un souffle aux stratégies d’allocation hors std. Mais le sujet le plus réclamé dans les commentaires se situe ailleurs : l’absence de stable ABI (interface binaire d’application stable).
  • Les lignes de fracture :
    1. Les adeptes de l’écosystème de plugins et de l’édition dynamique font valoir que la FFI de style C demeure l’unique canal d’interopérabilité avec les bibliothèques dynamiques ; sans stable ABI natif, tout système de plugins dynamiques doit écrire à la main des couches de glue C non sûres, ce qui pénalise lourdement micronoyaux, drivers propriétaires commerciaux et logiciels de bureau modulaires.
    2. Les contributeurs du cœur du compilateur écartent cette demande : figer l’ABI priverait rustc à jamais du réordonnancement des champs de struct, de l’évolution des conventions d’appel et de l’optimisation par inlining inter-crates — l’avantage de performance de Rust en sortirait nettement amputé. Garder pour axe principal la distribution par le code source et la compilation statique reste, de leur aveu, le meilleur compromis d’ingénierie. J’ai consulté les archives des discussions du conseil technique : officiellement, ce socle de conception ne changera pas dans un avenir prévisible.

🔭 À surveiller la semaine prochaine

  1. Découpage de la branche Beta de Rust 1.101.0 : conformément au cycle de 6 semaines, la première beta 1.101.0 sera taillée aux alentours du 20 novembre — l’occasion de vérifier l’état d’intégration du frontend parallèle et des dernières constantes de la bibliothèque standard.
  2. Surveillance des performances du frontend à deux threads sur Nightly : une fois le PR #162848 en place, suivre les données réelles d’occupation mémoire et d’utilisation CPU de la compilation parallèle de rustc sur les nœuds CI de chaque architecture et sur de grands dépôts open source (noyau Linux, Servo notamment).