C'est quoi Rust ? Pourquoi l'apprendre et comment l'installer

Rust est un langage de programmation compilé, à typage statique, conçu pour écrire des programmes rapides et sûrs en mémoire. Sa particularité : il libère la mémoire sans ramasse-miettes (garbage collector), grâce à des règles de propriété que le compilateur vérifie avant même que le programme ne tourne. Ce chapitre explique d'où vient Rust, pourquoi les agences de cybersécurité le recommandent, puis t'aide à l'installer et à lancer ton premier programme.

Rust en quelques dates

Rust publie une nouvelle version stable toutes les six semaines : 1.97 en juillet 2026, 1.98 en août, 1.99 en octobre, puis 1.100 mi-novembre : les numéros continuent simplement après 99. Ces versions ne cassent pas le code existant. Les changements plus profonds passent par les éditions (2015, 2018, 2021, 2024) : chaque projet déclare la sienne dans son fichier Cargo.toml, et un projet en édition 2021 compile toujours avec le dernier compilateur.

Pourquoi la sûreté mémoire compte

Un programme range ses données en mémoire, puis libère cette mémoire quand il n'en a plus besoin. En C et en C++, c'est au développeur de le faire à la main, et les erreurs sont faciles. Elles portent des noms que tu croiseras en cybersécurité :

Ces erreurs ne sont pas rares : en 2019, Microsoft indiquait qu'environ 70 % des vulnérabilités auxquelles il attribue chaque année un identifiant CVE sont des problèmes de sûreté mémoire, et l'équipe de Chromium (le moteur de Chrome) publiait un chiffre comparable pour ses failles graves.

Il existe deux grandes familles de solutions. La première est le ramasse-miettes de C#, Java, JavaScript ou Python : un programme qui tourne en même temps que le tien et libère ce qui n'est plus utilisé. C'est sûr, mais il consomme de la mémoire et du temps processeur, et ne convient pas à un noyau de système ou à un pilote. La seconde est celle de Rust : des règles de propriété (ownership) que le compilateur vérifie. Un programme qui pourrait utiliser une zone libérée ne compile tout simplement pas. Le chapitre 3 détaille ces règles.

Qui recommande et qui utilise Rust

Les agences de cybersécurité. L'ANSSI publie un guide, Règles de programmation pour le développement d'applications sécurisées en Rust (version 1.0 en 2020, tenue à jour en ligne sous le titre Développement sécurisé en Rust), qui présente Rust comme un langage « orienté vers la sûreté mémoire ». En décembre 2023, la CISA américaine et ses partenaires ont publié The Case for Memory Safe Roadmaps, qui demande aux éditeurs de prévoir le passage à des langages sûrs en mémoire. En juin 2025, la NSA et la CISA ont enfoncé le clou avec Memory Safe Languages: Reducing Vulnerabilities in Modern Software Development. Rust y figure aux côtés de C#, Java, Go, Python ou Swift : la recommandation porte sur la sûreté mémoire, pas sur un langage unique.

Les systèmes d'exploitation. Le noyau Linux accepte du code Rust depuis la version 6.1 (décembre 2022), surtout pour des pilotes ; en décembre 2025, ses mainteneurs ont décidé que Rust n'y était plus une expérience. Google écrit une part croissante d'Android en Rust et annonçait en novembre 2025 que les failles de sûreté mémoire étaient passées, pour la première fois, sous 20 % du total des failles d'Android. Microsoft livre dans Windows 11 des composants du noyau réécrits en Rust, comme une partie du pilote graphique win32kbase_rs.sys.

Les outils que tu utilises peut-être déjà. Des moteurs de Firefox, le proxy Pingora de Cloudflare, les outils Python uv et ruff, l'outil de recherche ripgrep (que VS Code utilise pour sa recherche dans les fichiers) sont écrits en Rust.

Rust face aux langages que tu connais

Rust emprunte aux langages fonctionnels (match, itérateurs, types Option et Result) et aux langages système (contrôle de la mémoire, pas de machine virtuelle). C'est ce mélange qui le rend un peu déroutant au début, et très agréable ensuite.

Installer Rust avec rustup

On installe Rust avec rustup, l'installeur officiel. Il installe le compilateur, l'outil cargo et la bibliothèque standard, puis il les met à jour.

Sous Linux et macOS, tape dans un terminal la commande donnée sur rustup.rs :

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

Accepte l'installation par défaut (choix 1), puis ouvre un nouveau terminal pour que les commandes soient trouvées.

Sous Windows, télécharge rustup-init.exe depuis rustup.rs et lance-le. Rust a besoin de l'éditeur de liens de Microsoft : si les outils de compilation C++ de Visual Studio ne sont pas installés, l'installeur te propose de les installer. Accepte, c'est le plus simple. Tu peux aussi travailler dans WSL et suivre la méthode Linux.

Vérifie ensuite l'installation :

rustc --version
cargo --version

rustc 1.99.1 (58cf8f9c3 2026-10-13)
cargo 1.99.1 (…)

Ton numéro de version peut être différent : ce qui compte, c'est que les deux commandes répondent. Si le terminal affiche command not found, ferme-le et rouvre-le ; sous Linux et macOS, source "$HOME/.cargo/env" recharge le chemin dans le terminal courant.

Quelques commandes rustup à connaître :

Côté éditeur, installe VS Code et l'extension rust-analyzer : complétion, types affichés au survol, erreurs soulignées pendant la frappe. Les IDE de JetBrains proposent aussi RustRover. Pour essayer un bout de code sans rien installer, le Rust Playground compile et exécute dans le navigateur.

Créer un projet avec cargo

Cargo est le gestionnaire de projets de Rust : il crée les projets, télécharge les bibliothèques, compile, lance les tests et produit la version finale. C'est l'équivalent de npm pour Node.js ou de dotnet pour C#. Tu l'utiliseras bien plus souvent que le compilateur rustc lui-même.

cargo new parc
cd parc

    Creating binary (application) `parc` package

Cargo a créé ce dossier, et initialisé un dépôt Git au passage :

parc/
├── .gitignore
├── Cargo.toml
└── src/
    └── main.rs

Le fichier Cargo.toml décrit le projet, au format TOML :

[package]
name = "parc"
version = "0.1.0"
edition = "2024"

[dependencies]

edition = "2024" fixe l'édition du langage. La section [dependencies] listera les bibliothèques externes, que Rust appelle des crates ; elle est vide pour l'instant.

Le fichier src/main.rs contient déjà un programme. Remplace son message par celui de l'outil :

fn main() {
    println!("Parc informatique de Sorbier Logistique");
}

• fn main() déclare la fonction principale, par laquelle le programme démarre.
• println! affiche une ligne. Le ! indique une macro, pas une fonction : une macro génère du code à la compilation. Tu en croiseras d'autres, comme format! et vec!.
• Les instructions se terminent par un point-virgule, et l'indentation de quatre espaces est la convention.

Lance le programme :

cargo run

   Compiling parc v0.1.0 (/home/julie/parc)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
     Running `target/debug/parc`
Parc informatique de Sorbier Logistique

cargo run compile, puis exécute. Le programme compilé est un vrai exécutable, rangé dans target/debug/parc (ou parc.exe sous Windows) : tu peux le copier sur une autre machine du même système et le lancer sans installer Rust.

Lire un message d'erreur du compilateur

Le compilateur de Rust refuse beaucoup de programmes que d'autres langages accepteraient. En échange, ses messages sont précis et proposent souvent la correction. Retire le ! de println! et relance cargo run :

fn main() {
    println("Parc informatique de Sorbier Logistique");
}

error[E0423]: expected function, found macro `println`
 --> src/main.rs:2:5
  |
2 |     println("Parc informatique de Sorbier Logistique");
  |     ^^^^^^^ not a function
  |
help: use `!` to invoke the macro
  |
2 |     println!("Parc informatique de Sorbier Logistique");
  |            +

Lis-le dans cet ordre :

1. Le code et le résumé : error[E0423]: expected function, found macro. Le code E0423 identifie le type d'erreur.
2. L'emplacement : src/main.rs:2:5, c'est-à-dire fichier, ligne 2, colonne 5. Les ^^^^^^^ soulignent le passage fautif.
3. L'aide : la ligne help: montre la correction, et le + marque ce qu'il faut ajouter.

Pour une explication complète, avec des exemples, tape rustc --explain E0423. Les messages sont en anglais ; le vocabulaire revient toujours, et ce cours traduit les erreurs les plus fréquentes au fil des chapitres.

Exercices

fn main() {
    let marque = "Dell"
    println!("Marque : {marque}");
}

error: expected `;`, found `println`
 --> src/main.rs:2:24
  |
2 |     let marque = "Dell"
  |                        ^ help: add `;` here
3 |     println!("Marque : {marque}");
  |     ------- unexpected token

fn main() {
    let marque = "Dell";
    println!("Marque : {marque}");
}