Rust

Rust 1.100.0 : type Never, fin de Windows 32, nouvelle sécurité sur Cargo

Soumis par francoistonic le
Image

Rust annonce la version 1.100.0 du langage. Les principales nouveautés sont : type Never, API Allocator / DropgGuard, évolutions sur Cargo, de nouvelles API stabilisées. 

1 / type Never

C'est une des principales nouveautés. Comme le précise l'équipe, il y aura fallu 10 ans et 5 tentatives de stabilisation pour y arriver. Le type never est noté !. Il s'agit d'un type canonique. "Il représente le type de calculs divergents – des calculs qui n'aboutissent jamais à aucune valeur – où tout code suivant est inaccessible. Les expressions qui interrompent le flux de contrôle, telles que `return`, `break` et `std::process::exit`, sont également de type !."

fn infallible_unwrap<T>(res: Result<T, !>) -> T {
    // ^^ writing `Result<_, !>` was not allowed before
    let Ok(v) = res;
    v
}

2 / Allocator 

Allocator permet d'utiliser des allocateurs mémoire personnalisés avec Vec et Box. 

3 / Cargo

Plusieurs évolutions et nouveautés concernent Cargo :

  • min-publish-age : impose un "âge" minimum avant d'accepter une nouvelle version d'une dépendance, par exemple 3 jours. Il s'agit d'une nouvelle sécurité
[registry]
global-min-publish-age = "3 days"
  • intégration d'un moteur d'analyse statique avec la règle unused_crate_dependencies qui signale si un Crates n'est jamais déclaré dans le code
  • réduction des problèmes de cache durant la compilation

Rust 1.100.0 retire définitivement le support du x86 32 bits. Cette version supporte Unicode 18.

Annonce : https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/

 

Ginux : un noyau codé avec l'IA en 11 jours avant changer d'avis

Soumis par francoistonic le

Le créateur de Ginux n'est pas un inconnu. Il s'agit de Gregory Kurtzer. Il oeuvrait sur CentOS et Rocky Linux. Ginux est un noyau compatible Linux et non un fort du kernel Linux. 

Il tient à le rappeler : "Ginux a débuté comme un noyau Rust indépendant démarrant directement via UEFI et exécutant un espace utilisateur Rocky Linux 10. Cette phase de recherche est terminée. Son code source final est archivé de façon permanente sur la branche `bootable-kernel` et sous l'étiquette `bootable-kernel-final`. Le développement actif se poursuit désormais ici en tant que noyau en espace utilisateur."

Il tourne sur architecture x64. Le projet ne promet pas une compatibilité totale avec Linux ABI. 

"On connaît tous le Vibe Coding, maintenant. Ma définition est légèrement différente : je l'imagine comme une personne qui ne maîtrise pas bien le sujet, demandant à une IA de faire quelque chose, et celle-ci « invente » (ou plutôt, « tâtonne ») la solution.

Même si on parle beaucoup de sa capacité à remplacer les développeurs et les humains compétents, je ne pense pas que les résultats soient exceptionnels.

En revanche, quand l'IA est pilotée par quelqu'un qui sait vraiment ce qu'il fait, on peut obtenir des résultats extraordinaires ! J'en ai été témoin moi-même, ainsi que chez d'autres, et les résultats sont exceptionnels. J'ai donc voulu mettre ma méthode à l'épreuve.

Je l'appelle Ingénierie Agentique Dirigée par l'Humain (IADH), et j'ai décidé de m'attaquer à une tâche un peu folle : quelque chose que je maîtrise, facile à tester et à améliorer, quelque chose qu'aucune personne sensée n'entreprendrait seule. Il s'agissait de créer un noyau de système d'exploitation capable d'exécuter Linux." explique le développeur. 

Oui mais...

Gregory a mis 11 jours pour concevoir les fondations de son noyau. Il a intensivement utilisé l'IA avant de le "tuer". Dans un post du 5 novembre, Greogry dit qu'il a abandonné le projet dans sa forme initiale. 

Il a vite été un peu dépassé par la curiosité suscitée par son projet. Et son objectif n'était pas d'assurer la maintenance de Ginux. Il réoriente Ginux vers autre chose : créer une interface noyau - espace utilisateur. Mais il avoue de ne pas trop savoir où cela ira. 

Pour suivre le projet : https://github.com/gmkurtzer/ginux

 

Discord passe d'Electron à Rust et divise par 13 la consommation mémoire

Soumis par francoistonic le
Image
Discord

Discord a confirmé la réécriture complète de son application Windows. Jusqu'à présent, l'éditeur utilisait Electron et React. Electron est pratique mais il est lourd et consomme beaucoup de mémoire. L'app Discord nécessitait jusqu'à 4 Go de RAM !

"Nous avons adopté Rust dès 2018 et une grande partie de notre infrastructure, de notre technologie vocale et même une partie de notre client actuel sont déjà écrites en Rust. Notre objectif ultime était de migrer l'intégralité du client vers ce langage. Cela signifie qu'Electron et React Native disparaissent. L'interface mobile conserve son ergonomie native, mais le code de l'application est partagé avec la version de bureau grâce à Rust. Nous espérons bientôt lancer des tests utilisateurs™. (Et ce n'est pas Tauri, c'est GPUI ; vous l'aviez deviné !)" explique le CTO.

La nouvelle version est écrite en Rust et le framework GPUI. Résultat : Discord Phoenix consomme 290 Mo de Ram sur Windows !

PHP-Rust : une implémentation de zéro de PHP en... Rust

Soumis par francoistonic le
Image

Et si on pouvait utiliser les codes et projets PHP sur un runtime totalement réécrit en Rust ? C'est le défi du projet PHP Rust. Une des difficultés est de garder une compatibilité optimale avec le code PHP tout remplaçant le moteur Zend et ses 270 000 lignes de C. Une des bases techniques du projet est phpt et les 21 500 tests officiels pour assurer la compatibilité avec le langage. Ce n'est donc pas une réécriture du code C actuel mais plutôt une réimplémentation en s'appuyant sur phpt. "Le résultat est un moteur où Rust effectue le gros du travail à coût nul : la propriété remplace zend_alloc, Rc+copy-on-write remplace le comptage de références manuel, Send/Sync fait du multithreading une propriété du type au lieu d'un sous-système (TSRM), et un processus résident rend le moteur prêt pour l'asynchrone par construction." explique le projet.

Cet environnement d'exécution PHP doit :

1 / être fidèle au langage avec une compatibilité bug à bug avec PHP 8.5

2 / assurer un haut niveau de confiance et de sécurité notamment sur la gestion mémoire

3 / apporter une couche moderne et sous la forme d'un binaire avec un serveur web natif

Créer un runtime n'est ni facile ni rapide. Sur les 13 phases du projet, les phases 1 à 9 sont complètes sauf une. Le travail d'optimisation est en cours. Un test crucial sera le bon fonctionnement de Composer, une véritable app exécutée de bout en bout. Le bytecode VM pèse environ 62 300 lignes de Rust contre 136 000. La partie HIR et compilateur représentent 19 200 lignes contre 12 400. 

Selon la page du projet : le langage de base est complet et même les fonctions avancées de PHP 8.4 et 8.5 sont présentes (ex. : propriétés hooks, lazy objects). Sur la roadmap de développement, Laravel sera le prochain framework à être supporté. 

Site : https://github.com/francescotinti/php-rust

LiteBox Sandboxing Library OS : un nouveau projet open source de Microsoft

Soumis par francoistonic le
Image

Annoncé en début d'année, Microsoft met en ligne la 1ere version de son LiteBox Sandboxing Library OS. Il s'agit de construire une sandbox sous la forme d'une Library OS en s'appuyant sur Rust et Linux. LiteBox permet de disposer de fonctions de sécurité Linux sous une forme virtualisée. Cette box permet d'isoler les apps Linux directement sur Windows. 

LiteBox contient que les fonctions indispensables pour réduire au maximum la surface d'attaque et la taille. Parmi les usages possibles, Microsoft en cite plusieurs :

- exécuter un programme Linux

- isoler une app Linux sur Linux 

- exécuter un programme au-dessus de SEV SNP

- exécuter LVBS

Contrairement à une virtualisation ou un conteneur, le projet propose une architecture en deux parties : Nord (Shims) et Sud (Platforms). Nord s'inspire de nix/rustix. "LiteBox expose une interface « Nord » inspirée de Rust et de nix/rustix lorsqu'une interface Platform lui est fournie au niveau de son interface « Sud ». Ces interfaces permettent une grande variété de cas d'utilisation, facilitant la connexion entre n'importe quelle paire Nord-Sud."

Microsoft devrait publier plus d'éléments dans les prochains mois. 

Le projet : https://github.com/microsoft/litebox

mold : un linker réécrit en Rust

Soumis par francoistonic le

mold est un linker offrant de hautes performances. Ecrit en C++, le projet a été réécrit en Rust. Il utilise le système de build Cargo à la place de CMake. La version corrige aussi de nombtreux bugs. Son développeur était à l'origine de LLVM lld puis il a décidé de créer un nouveau linker de 0. Aujourd'hui, il s'est imposé comme un linker référence. Il supporte x64, x86, RISC-V, Arm, PowerPC, Spark, m68k, etc.

« mold 3.0.0 est une nouvelle version majeure de ce éditeur de liens (linker) à haute vitesse. Comme nous l'avions annoncé dans les notes de version de la 2.42.1, nous avons réécrit mold de C++ vers Rust, et il s'agit de la toute première version écrite en Rust. La version 2.42.1 est la dernière déclinaison en C++. L'objectif de mold 3.x est de combler les derniers écarts de compatibilité avec GNU ld, en particulier concernant la prise en charge des scripts d'édition de liens (linker scripts), et de préparer le terrain pour que mold devienne l'éditeur de liens par défaut dans les distributions Linux. »

Note de version : https://github.com/rui314/mold/releases/tag/v3.0.0

Rust 1.100 retirera le support de Windows 32 bits

Soumis par francoistonic le

Actualité par la rédaction de Programmez!

L'équipe du compilateur de Rust a annoncé le 2 octobre qu'à partir de Rust 1.100.0, les deux cibles Windows 32 bits perdront leurs outils hôtes. i686-pc-windows-msvc passe de Tier 1 avec outils hôtes à Tier 1 sans outils hôtes ; i686-pc-windows-gnu de Tier 2 avec outils hôtes à Tier 2 sans. La bibliothèque standard précompilée reste distribuée, et la cible MSVC reste testée en intégration continue, mais la compilation ne sera plus fournie pour ces plateformes.

La production de binaires Windows 32 bits restera possible par compilation croisée depuis un hôte pris en charge, par exemple une toolchain Windows 64 bits avec la cible i686 ajoutée. Les autres plateformes 32 bits ne sont pas concernées.

L'équipe justifie ce choix : plus aucun processeur x86 32 bits n'a été vendu depuis quinze ans pour le poste de travail ou le serveur, fin du support général de Windows 32 bits en octobre 2025, et des builds de toolchains i686 devenus problématiques, avec des plantages du compilateur côté MSVC et des dépassements de mémoire de LLVM côté GNU. Les détails sont dans la RFC 3999 pour la cible MSVC et la MCP 1020 pour la cible GNU.

Annonce : https://blog.rust-lang.org/2026/10/02/demoting-i686-windows-targets-to-std-only/

esp-notify : un moniteur desk avec une ESP32-C6

Soumis par francoistonic le
Image

Voilà un petit projet maker comme nous les aimons : esp-notify. Il utilise :

- un ESP32-C6

- Rust et Ratatui

L'ESP utilisé est un modèle de Waveshae : l'ESP32-C6-LCD-1.47. Le projet permet de monitorer GitHub, Cloudflare, Tailscale, OpenAI, Anthropic. Les métriques sont mises à jour toutes les 5 secondes. Les LED donnent l'état des services. Les notifications sont envoyées (POST / notify) en magenta. 

GitHub : https://github.com/fkhadra/esp-notify

Rust 1.99.0 est disponible

Soumis par francoistonic le

Rust 1.99.0 esr disponible depuis quelques jeures. Les principales nouveautés sont :

- variadics C externe : le langage stabilise les fonctions C-ABI variadics. Les fonctions variadics utilisent une liste d'arguments et accepte un nombre arbitraire d'arguments. Désormais, il est possible de les écrires directement en Rust

/// SAFETY: must be called with (at least) 2 i32 arguments.

unsafe extern "C" fn sum(mut args: ...) -> i32 {

// SAFETY: guaranteed by the caller.

let a = unsafe { args.next_arg::<i32>() };

let b = unsafe { args.next_arg::<i32>() };

a + b }

fn foo() -> i32 { unsafe {

sum(0i32, 2i32) }

}

- stabilisation de nouvelles API : 

    Sur Cargo, on dispose d'un nouveau profil debug. 

    Note complète : https://doc.rust-lang.org/stable/releases.html#version-1990-2026-10-01

    Comment GitHub a réécrit le runtime Copilot en Rust en utilisant... Copilot ?

    Soumis par francoistonic le
    IA
    Image

    GitHub a publié un long post sur la migration du runtime GitHub Copilot en Rust, en utilisant Copilot. Cela représente plus de 800 000 lignes de code. Que ce soit la CLI, Copilot appl ou encore le SDK, ils reposent sur l'environnement d'exécution de l'agent Copilot. A l'origine, il était écrit en TypeScript sur Node.js et V8. Fondamentalement, l'architecture a peu évolué. Mais avec l'arrivée de l'app et de la CLI, les équipes ont décidé de migrer le code du runtime en Rust. 

    "La majeure partie du code a été écrite par des agents, soit 128 demandes de fusion intégrées à la branche principale et déployées progressivement, évitant ainsi une migration finale unique. Les quelques régressions inévitables ont été rapidement détectées et corrigées, tandis que les performances de l'environnement d'exécution ont été considérablement améliorées. Un projet qui aurait nécessité une équipe complète de développeurs pendant un an ou deux avant l'intégration des agents a été réalisé en grande partie par un seul développeur, en quelques mois seulement, tandis que le reste de l'équipe continuait d'étendre significativement les capacités et la portée de l'environnement d'exécution." explique le post.

    Pourquoi cette migration ? 

    La multiplication des services et des outils Copilot pèse forcément sur le runtime. De nombreuses contraintes ont dicté le choix de Rust, par exemple : un langage ayant un minimum de dépendances, intégrer proprement des processus, avoir un niveau de performance, d'évolution et de fiabilité, un langage interopérable pour supporter facilement les différents SDK (C#, TypeScript, Python, Rust, Go et Java), une sécurité par défaut.

    Rust fut donc choisi mais au départ, l'idée n'était pas de tout réécrire en Rust : "Nos exigences privilégiaient l'intégration via une ABI C, une faible surcharge au démarrage et en régime permanent, et une utilisation prévisible des ressources."

    Deux tâches essentielles ont été menées :

    1/ Séparer le code spécifique à l'interface TUI du runtime, afin que le premier repose entièrement sur le second, et plus précisément sur l’interface publique du SDK. Aujourd’hui, l’interface de ligne de commande (CLI) accède encore directement aux composants internes du moteur d’exécution à plusieurs endroits ; son intégration complète à l’interface publique du SDK est en cours.2/ Porter cette couche d’exécution en Rust à 100 %, ce qui donne un binaire natif exposant une ABI C pour une utilisation en interne par tous les frontaux du langage, ainsi qu’un serveur basé sur l’entrée/sortie standard ou sur des sockets pour les cas où une exécution hors processus est souhaitée.130 000 lignes à migrer... dans la 1ere estimationUn tel chantier ne s'improvise pas. Le plan d'action a été établi en mai 2026. 130 000 lignes TypeScript étaient concernées. Mais la réalité n'était pas celle-ci :1 / du code lié à la couche TUI n'était pas inclus et il fallait l'intégrer aux codes du runtime2 / il fallait prendre en compte les évolutions liées aux pull requests, soit un volume de code non négligeable.Au final, ce sont plus de 430 000 lignes de TypeScript qui devaient être migrées... "This is confused further because there was also incoming Rust code, separate from the port, over the timeframe; early in the porting effort, incoming code was more likely to be dominated by TypeScript, whereas later in the effort, it was more likely to be dominated by Rust.". Bref, on comprend que lancer une migration de cette ampleur ne s'improvise pas et qu'il fallait bien délimiter les codes concernés mais en les 1eres estimations et le code réellement migré a été multiplié par 6 !Il est intéressant de voir le volume de code au fur et à mesure de la migration. En réalité, il fallait prendre en compte le code TypeScript de production mais aussi tous les tests unitaires TypeScript. On comprend immédiatement que l'estimation de 130 000 lignes n'était pas réaliste car il y avait dès le départ : env. 160/170 000 lignes en production et 250 000 lignes de tests unitaires !Au final, le projet a généré 830 000 lignes de code en Rust et 469 000 pour les tests unitaires ! "Lors de la migration, l'environnement d'exécution a intégré environ 300 000 lignes de production TypeScript et en a supprimé environ 430 000, tandis qu'environ 1 200 000 lignes de production Rust ont été intégrées et environ 365 000 supprimées. Autrement dit, la stabilité apparente de la ligne TypeScript dans le graphique masquait en réalité une importante activité liée à TypeScript."A partir de là, l'équipe s'est interrogée sur la stratégie à adopter :- soit une migration radicale ou big bang : le runtime Rust comme une alternative complète et intégrée quand il est totalement prêt et terminé. Cette approche a deux conséquences :a. Arrêt complet du développement. Toute activité sur la branche principale est interrompue pendant la réécriture, celle-ci étant effectuée dans la branche principale.b. Développement parallèle. La réécriture a lieu dans une branche de fonctionnalité tandis que le travail se poursuit sur la branche principale. La réécriture s'efforce constamment de suivre et d'intégrer les modifications de la branche principale.- soit une migration composant par composant avec réécriture progressive avec réduction de TypeScript. Une des options de cette approche est "plutôt que de supprimer les composants au fur et à mesure de leur portage, les composants TypeScript et Rust sont maintenus comme des options interchangeables à chaud, le composant TypeScript étant supprimé une fois que le niveau de confiance s'est stabilisé."

    Finalement, l'option 2 avec suppession progressive des composants TypeScript fut choisie pour plusieurs raisons dont :

    - pas d'arrêt de production

    - la branche principale est toujours prête à être déployée

    - réécriture incrémentale

    - des migrations par petits morceaux et relativement autonomes

    - tests de bout en bout

    Avant de lancer le chantier, un PoC limité a été réalisé : "Avant de nous lancer pleinement, nous avons gagné en confiance et validé nos hypothèses. Nous avons commencé par deux pull requests qui ont établi l'espace de travail Rust, la chaîne d'outils, les règles de lint, l'intégration continue, le pipeline de compilation et les instructions de codage. Nous avons ensuite introduit la bibliothèque d'exécution, la génération de code et les modèles d'interopérabilité, tout en portant une collection de primitives de logique pure, choisies précisément pour leur absence d'E/S et d'état partagé, et parce qu'elles bénéficiaient déjà de tests robustes. Ce n'est qu'après l'intégration de ces primitives que la première pull request de portage majeure a permis de porter trois utilitaires sans effets de bord tout au long du processus."

    Interopérabilité : un point crucial

    Cette migration devait assurer l'interopérabilité entre TypeScript, Rust et l'ensemble des SDK disponibles :

    1 / s'assurer que durant la migration vers Rust, le module concerné TypeScript était toujours accessible et que les fonctions Rust puissent appeler du TypeScript en callback

    2 / toutes les librairies des SDK doivent pouvoir s'appuyer sur le runtime et exposer les fonctionnalités. 

    Une migration d'un langage à un autre n'était pas uniquement une réécriture. Il a fallu remplacer les bibliothèques utilisées par le runtime. Elles ne dépendent pas de GitHub. Certaines étaient quasi identiques, d'autres nécessitaient plusieurs crates. La migration a permis de supprimer 60 dépendances npm.

    Cette migration n'a pas échappé aux régressions. Il est quasi impossible d'avoir un comportement strictement identique sur une telle quantité de code. Les équipes rappellent un axiome simple : porter du code c'est facile, le corriger l'est beaucoup moins : "Au 14 septembre 2026, nous avions recensé des dizaines de régressions connues, toutes corrigées. La plupart étaient des bugs, avec un plus petit nombre de régressions de performance." Il n'y a pas 0 régression et toutes n'ont pas été détectées. 

    Le passage à Rust a permis des gains de performance et une consommation RAM moindre.

    Au final...

    Cette migration représente :

    136 milliards de tokens

    120 000 $ : c'est le coût estimé pour la partie agentique uniquement

    Bien entendu, il a fallu toute une équipe : une dizaine de développeurs pour le cœur du projet, et un nombre non précisé d'autres intervenants pour les pull requests et les approbations. Les leçons tirées de cette expérience

    Les leçons tirées de cette expience

    1 / il faut un objectif clair et précis, ne pas avoir d'estimations approximatives 

    2 / des tests de bout en bout et tout le temps. C'EST INDISPENSABLE. 

    3 / prévenir et protéger de toute action de l'agent non prévue ou demandée 

    4 / traduire d'abord, redesigner après : il faut préserver le comportement, par exemple sur le code concurrent ou la gestion des droits. Chaque écart peut engrendrer des régressions et des comportements anormaux.

    5 / transformer un échec en futur succès : un agent peut dévier, il faut en tirer des leçons. 

    Post complet : https://github.blog/ai-and-ml/generative-ai/migrating-the-github-copilot-runtime-to-rust-using-copilot/