Le langage Rust

Rust est un langage système qui offre la vitesse du C sans ses erreurs de mémoire, grâce à un modèle d'ownership vérifié à la compilation, sans ramasse-miettes. Concrètement, une classe entière de bugs (accès après libération, dépassement de tampon, data races) est rejetée avant l'exécution. Ce guide installe la toolchain proprement, crée un premier programme avec Cargo, et explique le concept central, l'ownership. Public visé : développeurs curieux de Rust, à l'aise avec un autre langage. Testé avec Rust 1.96.

Ce que vous allez apprendre

Comprendre pourquoi Rust est à la fois rapide et sûr.
Installer la toolchain avec rustup, sans curl | sh.
Créer et exécuter un premier programme avec Cargo.
Saisir le modèle d'ownership et l'emprunt sur un exemple.

Pourquoi Rust

La plupart des langages système (C, C++) laissent le développeur gérer la mémoire à la main : c'est puissant, mais c'est la source de la majorité des failles de sécurité critiques. À l'opposé, les langages à ramasse-miettes (Go, Java) évitent ces bugs, au prix de pauses et d'une empreinte mémoire plus lourde.

Rust prend une troisième voie : le compilateur suit qui possède chaque valeur et jusqu'à quand elle vit, puis refuse de compiler tout code qui violerait ces règles. Résultat : la sûreté mémoire est garantie sans ramasse-miettes, avec des performances comparables au C. C'est pourquoi Rust est adopté pour des composants critiques du noyau Linux, des navigateurs et des outils d'infrastructure.

Installer Rust

L'outil officiel est rustup, qui gère les versions du compilateur (rustc) et du gestionnaire de paquets (cargo). La page officielle propose un curl … | sh, à éviter : sur Debian et Ubuntu récents, rustup est disponible en paquet.

sudo apt install rustup
rustup default stable

rustup default stable télécharge la dernière version stable et en fait la toolchain par défaut. Vérifiez ensuite l'installation :

rustc --version

rustc 1.96.1 (31fca3adb 2026-06-26)

Premier programme avec Cargo

Cargo est le couteau suisse de Rust : il crée les projets, compile, exécute, teste et gère les dépendances. On ne lance quasiment jamais rustc à la main. Créez un projet :

cargo new hello
cd hello

Cargo génère une arborescence standard : un fichier de configuration Cargo.toml (métadonnées et dépendances) et un src/main.rs contenant déjà un « Hello, world! ». Compilez et exécutez le tout avec une seule commande :

cargo run

   Compiling hello v0.1.0 (/tmp/hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.34s
     Running `target/debug/hello`
Hello, world!

cargo run compile puis lance le binaire. Pour compiler sans exécuter, utilisez cargo build ; pour une version optimisée destinée à la production, cargo build --release.

L'ownership en une minute

L'ownership est l'idée centrale de Rust. Chaque valeur a un unique propriétaire (une variable) ; quand le propriétaire sort de sa portée, la mémoire est libérée automatiquement, sans ramasse-miettes. Pour utiliser une valeur ailleurs sans en transférer la propriété, on la prête avec une référence & : c'est un emprunt.

Remplacez src/main.rs par cet exemple, qui affiche une chaîne via une fonction sans en perdre la propriété :

fn main() {
    let message = String::from("Bonjour Rust");
    afficher(&message);                 // on prête la valeur (emprunt)
    println!("Toujours accessible : {message}");
}

fn afficher(texte: &str) {
    println!("{texte}");
}

cargo run

Bonjour Rust
Toujours accessible : Bonjour Rust

La fonction afficher reçoit un emprunt (&str) : elle peut lire la chaîne mais n'en devient pas propriétaire. Après l'appel, message reste utilisable dans main. Si on avait passé message sans &, sa propriété aurait été transférée (move) à la fonction, et la ligne suivante ne compilerait pas. C'est cette vérification, faite par le compilateur, qui élimine les accès mémoire invalides.

Aller plus loin

Rust a une courbe d'apprentissage réputée exigeante, surtout autour de l'ownership et du borrow checker. La bonne nouvelle : les messages d'erreur du compilateur sont parmi les plus pédagogiques de l'écosystème, et pointent souvent la correction. Les ressources suivantes accompagnent la suite.

Site officiel : Rust-lang.org (fr).
Traduction française du Rust Book, la référence pour apprendre.
Tutoriels Rust de Guillaume Gomez.
Parlons peu, parlons Rust, en vidéo.

À retenir

Rust garantit la sûreté mémoire sans ramasse-miettes : les bugs mémoire sont rejetés à la compilation.
Installez la toolchain avec rustup (paquet distro), pas avec curl | sh.
Cargo pilote tout : cargo new, cargo run, cargo build --release.
L'ownership donne un propriétaire unique à chaque valeur ; l'emprunt (&) prête une valeur sans en transférer la propriété.
Le borrow checker paraît strict au début, mais ses messages guident la correction.

Prochaines étapes

Créer une CLI Python avec Click Comparer l'approche Rust avec un langage de plus haut niveau pour les outils en ligne de commande.

Le langage Go L'autre langage système moderne, avec ramasse-miettes et concurrence intégrée.

Signer ses artefacts (Cosign) Sécuriser la distribution des binaires que vous compilez.