Retour aux articles

Apprendre Rust en 2026 : pourquoi, et pour construire quoi

Rust 13 min de lecture

Mis à jour le 17 novembre 2026. Plusieurs projets cités ici sont en cours de développement : leur état est précisé à chaque fois, avec le lien vers la source.

Logo du langage Rust Image : rust-lang.org.

Rust 1.100.0 est sorti le 12 novembre 2026 (annonce). Une semaine plus tôt, le directeur technique de Discord annonçait la réécriture de tout le client en Rust. Entre les deux, vous avez peut-être installé uv, ripgrep ou Zed sans vous demander dans quel langage ils étaient écrits.

Cet article s'adresse aux développeurs web qui viennent de PHP ou de JavaScript et qui se demandent si Rust vaut le temps qu'il demande. Il explique ce que le langage a de particulier, ce qu'on construit avec, qui l'utilise réellement, ce qui est difficile, et par où commencer. Rust n'est pas la bonne réponse à tous les projets, et la dernière partie dit dans quels cas un autre choix est plus raisonnable.

L'essentiel en quelques lignes

  • Rust est un langage compilé qui vérifie à la compilation la façon dont le code utilise la mémoire, sans ramasse-miettes.
  • Il sert surtout là où la performance et la maîtrise des ressources comptent : outils en ligne de commande, services réseau, composants système, applications de bureau.
  • Pour un développeur web, les portes d'entrée les plus naturelles sont un petit outil en ligne de commande et Tauri, qui garde l'interface en HTML, CSS et JavaScript.
  • Composer reste écrit en PHP. Les outils en Rust qui reproduisent une partie de son fonctionnement sont des projets indépendants.
  • L'apprentissage est exigeant, et les premières semaines se passent en grande partie à comprendre pourquoi le compilateur refuse du code qui semblait correct.

D'où vient Rust

Rust commence comme un projet personnel de Graydon Hoare, alors employé de Mozilla. Le blog du projet situe sa conception en 2010, comme projet de Mozilla Research, et ajoute que l'on peut remonter à 2006 selon la façon de compter (Rust Blog). La question de départ : obtenir les performances et le contrôle des langages système en supprimant une famille d'erreurs de mémoire et de concurrence.

Date Événement
Vers 2006 Premiers travaux de Graydon Hoare.
2010 Rust devient un projet de Mozilla Research.
15 mai 2015 Rust 1.0, avec une promesse de stabilité et de compatibilité.
Août 2020 Mozilla licencie environ 250 personnes, dont des membres actifs du projet. L'équipe annonce un projet de fondation.
2021 Création de la Rust Foundation.
Décembre 2025 Les mainteneurs du noyau Linux retirent l'étiquette « expérimental » de Rust dans le noyau (LWN).
12 novembre 2026 Rust 1.100.0.

Ce qui le distingue

Un compilateur qui vérifie qui possède quoi

L'idée centrale de Rust s'appelle l'ownership (possession). Chaque valeur a un seul propriétaire à la fois. Quand ce propriétaire sort de la portée, la mémoire est libérée, sans ramasse-miettes et sans free à écrire (The Rust Programming Language).

Ce programme ne compile pas :

fn main() {
    let noms = vec![String::from("Ada"), String::from("Margaret")];
    let autre = noms;          // la valeur est déplacée vers `autre`
    println!("{:?}", noms);    // refusé : `noms` ne possède plus rien
}

Le compilateur répond ceci :

error[E0382]: borrow of moved value: `noms`
 --> move.rs:4:22
  |
2 |     let noms = vec![String::from("Ada"), String::from("Margaret")];
  |         ---- move occurs because `noms` has type `Vec<String>`, which does not implement the `Copy` trait
3 |     let autre = noms;          // la valeur est déplacée vers `autre`
  |                 ---- value moved here
4 |     println!("{:?}", noms);    // refusé : `noms` ne possède plus rien
  |                      ^^^^ value borrowed here after move
  |
help: consider cloning the value if the performance cost is acceptable

En PHP ou en JavaScript, ce code fonctionnerait : les deux variables désigneraient le même tableau. Rust l'interdit parce que deux propriétaires pour une même valeur rendent possibles les libérations en double et les accès à de la mémoire déjà libérée.

La solution courante est le borrowing (emprunt) : on prête la valeur avec une référence au lieu de la donner.

fn afficher(noms: &Vec<String>) {
    println!("{:?}", noms);
}

fn main() {
    let noms = vec![String::from("Ada"), String::from("Margaret")];
    afficher(&noms);           // on prête la valeur, on ne la donne pas
    println!("{} noms", noms.len());
}

La partie du compilateur qui applique ces règles s'appelle le borrow checker (vérificateur d'emprunt). Il vérifie aussi qu'une référence ne survit pas à la valeur qu'elle désigne, grâce aux lifetimes (durées de vie), et qu'une donnée n'est pas modifiée à un endroit pendant qu'elle est lue ailleurs. Cette dernière règle est celle qui empêche une partie des accès concurrents entre threads.

Pas de null, pas d'exceptions

Rust n'a pas de valeur nulle. Une valeur qui peut manquer est un Option, et une opération qui peut échouer renvoie un Result. Le compilateur oblige à traiter les deux cas.

use std::fs;

fn lire_port(chemin: &str) -> Result<u16, String> {
    let contenu = fs::read_to_string(chemin)
        .map_err(|e| format!("lecture impossible : {e}"))?;

    contenu
        .trim()
        .parse::<u16>()
        .map_err(|e| format!("port invalide : {e}"))
}

fn main() {
    match lire_port("port.txt") {
        Ok(port) => println!("Port : {port}"),
        Err(message) => eprintln!("Erreur : {message}"),
    }
}

Le ? renvoie l'erreur à l'appelant si l'opération échoue. La signature de la fonction dit qu'elle peut échouer, ce qu'une exception PHP ne montre pas.

Des outils fournis avec le langage

rustup installe et met à jour le compilateur. cargo crée les projets, gère les dépendances, compile, lance les tests et publie. rustfmt formate le code et clippy signale les maladresses. Un développeur habitué à Composer ou à npm retrouve vite ses repères avec Cargo.toml et cargo add.

Ce que Rust ne garantit pas

Rust a un mot-clé unsafe, qui autorise des opérations que le compilateur ne peut pas vérifier (documentation). Un programme Rust peut aussi contenir des erreurs de logique, des dépendances vulnérables ou une mauvaise configuration.

Google en donne un exemple concret. En novembre 2025, son équipe Android a décrit un dépassement de tampon trouvé dans du code unsafe de CrabbyAVIF, un composant écrit en Rust. La faille, CVE-2025-48530, a été corrigée avant d'atteindre une version publique (Google Security Blog). Le même article indique que les failles de sécurité mémoire sont passées sous les 20 % du total des vulnérabilités d'Android en 2025, et que la densité de ces failles est environ mille fois plus faible dans le code Rust d'Android que dans son code C et C++.

Pourquoi on en parle autant

Dans l'enquête Stack Overflow de 2025, Rust est le langage le plus « admiré » : 72,4 % de ceux qui l'ont utilisé veulent continuer. Dans la même enquête, 14,8 % des répondants disent s'en servir (Stack Overflow Developer Survey 2025). Les deux chiffres mesurent des choses différentes, et ils viennent d'un questionnaire rempli par des volontaires.

L'enquête de la communauté Rust publiée en mars 2026 a réuni 7 156 réponses, et ses auteurs préviennent qu'on ne peut pas trop extrapoler à partir de cet échantillon. Elle est utile pour une autre raison : la liste des problèmes cités par les utilisateurs eux-mêmes commence par la lenteur de compilation, l'espace disque consommé et un débogage jugé médiocre (State of Rust Survey 2025).

Ce qu'on peut construire

Des outils en ligne de commande

C'est le terrain où Rust est le plus visible au quotidien. ripgrep cherche du texte, fd cherche des fichiers, bat les affiche avec coloration. Côté Python, uv gère projets et paquets, et Ruff fait office de linter et de formateur. Ces outils se distribuent sous la forme d'un exécutable unique, sans runtime à installer.

Pour un développeur PHP, un premier outil peut être très modeste. Celui-ci liste les paquets de la section require d'un composer.json :

cargo new composer-check
cd composer-check
cargo add serde_json
use std::{env, fs, process};

use serde_json::Value;

fn main() {
    let chemin = env::args().nth(1).unwrap_or_else(|| "composer.json".to_string());

    let contenu = fs::read_to_string(&chemin).unwrap_or_else(|e| {
        eprintln!("Impossible de lire {chemin} : {e}");
        process::exit(1);
    });

    let json: Value = serde_json::from_str(&contenu).unwrap_or_else(|e| {
        eprintln!("JSON invalide dans {chemin} : {e}");
        process::exit(1);
    });

    match json["require"].as_object() {
        Some(paquets) => {
            for (nom, contrainte) in paquets {
                println!("{nom} {}", contrainte.as_str().unwrap_or("?"));
            }
        }
        None => println!("Aucune section \"require\" dans {chemin}"),
    }
}
cargo run
# php >=8.3
# symfony/console ^7.2

Des applications de bureau

Il y a deux approches. La première garde les technologies web. Tauri affiche une interface en HTML, CSS et JavaScript dans la webview du système, et la logique de l'application peut être écrite en Rust. Comme il n'embarque pas de moteur de navigateur, sa documentation annonce qu'une application minimale peut peser moins de 600 Ko. N'importe quel framework qui produit du HTML, du CSS et du JavaScript convient, et Tauri vise aussi Android et iOS. Sur mobile, l'interface reste une page web affichée dans une webview et n'utilise pas les composants natifs du système.

npm create tauri-app@latest

Visuel de la documentation de Tauri Image : Tauri.

La seconde approche dessine l'interface sans HTML. GPUI, le framework créé par l'équipe de l'éditeur Zed, utilise directement le GPU. Zed est sorti en version 1.0 le 29 avril 2026 pour macOS, Windows et Linux, et ses auteurs disent que des centaines de milliers de développeurs s'en servent chaque jour (Zed is 1.0). Iced et egui sont deux autres bibliothèques d'interface, avec des choix différents sur le rendu, l'accessibilité et les plateformes.

Visuel de lannonce de Zed 10 Image : Zed.

Des services web et des API

Axum et Actix Web sont les deux frameworks les plus cités, et Tokio fournit le runtime asynchrone sur lequel Axum repose. Un service minimal avec Axum 0.8 :

cargo add axum
cargo add tokio --features full
use axum::{routing::get, Router};

#[tokio::main]
async fn main() {
    let app = Router::new().route("/", get(|| async { "Bonjour depuis Axum" }));

    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();

    axum::serve(listener, app).await.unwrap();
}

Cela ne veut pas dire qu'une API classique doit être réécrite. Pour une application de gestion avec formulaires, base de données et back-office, Symfony, Laravel ou Node.js livrent plus vite avec une équipe qui les connaît. Rust devient intéressant pour un service précis qui traite beaucoup de données ou de connexions, ou dont la latence doit rester stable.

Des composants système

Android utilise Rust dans son noyau, dans du firmware et dans plusieurs composants de sécurité et de réseau, pour le code nouveau et sans réécriture systématique de l'existant (Google, 2022).

Ubuntu fournit un exemple plus nuancé. Depuis la version 25.10, sudo et les utilitaires de base sont fournis par des réimplémentations en Rust, sudo-rs et uutils coreutils. Dans son point d'étape d'avril 2026, Canonical rapporte que deux audits de sécurité ont relevé 113 problèmes et conduit à 45 CVE. Dans Ubuntu 26.04 LTS, cp, mv et rm restent fournis par GNU coreutils en attendant la correction de problèmes de concurrence d'accès aux fichiers (Ubuntu Discourse). Réécrire un outil en Rust supprime une classe d'erreurs. Les erreurs de logique restent, et la compatibilité avec l'original se vérifie cas par cas.

WebAssembly, mobile et jeux

Rust se compile en WebAssembly, ce qui permet de déplacer dans le navigateur un traitement lourd en gardant JavaScript ou TypeScript pour l'interface (The Rust and WebAssembly Book). L'intérêt dépend du coût des échanges de données entre les deux mondes. Sur mobile, Rust sert le plus souvent à partager de la logique entre Android et iOS. Pour le jeu, Bevy est un moteur open source écrit en Rust.

Discord : une réécriture annoncée, pas encore livrée

Discord utilise Rust depuis longtemps. En février 2020, l'entreprise a expliqué pourquoi elle avait réécrit en Rust son service « Read States », qui retient quels salons et quels messages chaque utilisateur a lus. La version en Go subissait des pics de latence toutes les deux minutes environ, au moment où le ramasse-miettes parcourait un grand cache en mémoire. La version en Rust n'avait plus ces pics et faisait mieux sur la latence, le processeur et la mémoire (Discord). L'entreprise a aussi décrit des services en Rust dans son stockage des messages.

Le 5 novembre 2026, Stanislav Vishnevskiy, cofondateur et directeur technique, a annoncé sur X que tout le client passait en Rust : « Electron disparaît, React Native aussi, le mobile garde une interface native mais partage le code applicatif avec le bureau via Rust » (The Verge). D'après IT-Connect, l'interface de bureau s'appuie sur GPUI, la webview du système resterait utilisée pour certaines intégrations, et une première version pour Windows affichait 290 Mo de mémoire vive avec deux comptes connectés.

Capture du futur client Discord publie par ITConnect Image : IT-Connect.

Ce client n'est pas disponible. Discord dit espérer le faire tester par des utilisateurs bientôt et n'a donné aucune date. Les chiffres de mémoire viennent d'une démonstration de l'entreprise, sur une version qui n'est pas terminée.

PHP : des alternatives à Composer écrites en Rust

Composer, le gestionnaire de dépendances de l'écosystème PHP, est écrit en PHP et le reste. Il n'a pas été porté en Rust. Ce qui existe, ce sont des projets indépendants qui reproduisent ou accélèrent une partie de son travail.

  • Vivacity réimplémente cinq commandes : install, update, require, remove et dump-autoload. L'outil ePHPm l'intègre, et sa documentation est explicite : « ephpm composer n'est pas Composer ». En dehors de ces cinq commandes, il passe la main à un vrai Composer ou s'arrête sur une erreur (ePHPm).
  • Composr vise l'installation à froid des projets Laravel. Il fonctionne en mode hybride : quand un script appelle une méthode de classe PHP, il délègue cet événement au vrai Composer. Ses auteurs mesurent, sur une application de 292 paquets et sans aucun cache, environ 33 secondes contre 72 avec Composer. C'est leur mesure, sur leur projet.
  • Libretto lit composer.json et composer.lock. Ses auteurs le présentent comme un logiciel alpha, expérimental, qui ne remplace pas Composer tel quel, parce que les plugins Composer sont du code PHP qu'un programme Rust ne peut pas exécuter sans interpréteur.

Avant d'en utiliser un sur un vrai projet, vérifiez la compatibilité avec vos plugins et vos scripts, et gardez Composer comme référence en production.

Ce qui coûte

Pour quelqu'un qui vient de PHP ou de JavaScript, plusieurs notions sont nouvelles en même temps : la possession et l'emprunt, les durées de vie, la gestion d'erreurs avec Result, les contraintes sur le partage de données entre threads, et les différences entre code synchrone et asynchrone. Le compilateur refuse du code qui paraît correct, et il faut du temps avant que ses refus deviennent prévisibles. Ses messages aident, comme celui montré plus haut, qui indique la ligne fautive et propose une correction.

Les temps de compilation sont le premier reproche des utilisateurs dans l'enquête de 2026. La maturité des bibliothèques varie beaucoup d'un domaine à l'autre. Dans une équipe, le temps de formation et la difficulté à recruter comptent autant que les qualités du langage.

Rust n'est probablement pas le premier choix pour un site ou une application de gestion classique, pour un prototype à livrer vite, ou pour un projet dont l'équipe ne compte personne qui le connaît. Il complète PHP, JavaScript ou Python sur des besoins précis et n'oblige à rien réécrire.

Par où commencer

L'installation passe par rustup (page officielle) :

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

cargo new bonjour
cd bonjour
cargo run

Les ressources gratuites :

Quelques premiers projets à la portée d'un développeur web :

  1. un outil en ligne de commande qui cherche du texte dans un projet ;
  2. un programme qui lit un fichier JSON ou CSV et produit un rapport ;
  3. un utilitaire qui inspecte des composer.json ou des package.json, comme l'exemple plus haut ;
  4. une petite API avec Axum ;
  5. une application de bureau avec Tauri, en gardant une interface web.

Sources

Le langage et son histoire :

Enquêtes :

Projets et entreprises :

PHP et Composer :


Article écrit par Jatniel, développeur full stack PHP senior.

Me retrouver sur LinkedIn, GitHub et X.

Partager cet article

J’aimerais utiliser Google Analytics pour savoir quelles pages vous sont utiles. Rien n’est déposé sans votre accord. En savoir plus