1. Chaîne d'outils et Cargo

Les trois outils

Rust	Rôle	C#	Java
rustup	installe et met à jour les chaînes d’outils	installeur du SDK .NET / global.json	SDKMAN!, installeurs du JDK
cargo	compiler, exécuter, tester, ajouter des dépendances	CLI dotnet	Maven / Gradle
crates.io	registre public de paquets	NuGet	Maven Central
rustc	le compilateur (Cargo l’appelle pour vous)	Roslyn (csc)	javac

Installation

Rust s’installe avec rustup sur tous les OS. Rust utilise l’éditeur de liens (linker) de la plateforme, donc chaque OS a aussi besoin de ses outils de build C natifs.

Windows

winget install Rustlang.Rustup

Ou téléchargez rustup-init.exe depuis rustup.rs. La chaîne d’outils par défaut cible MSVC : il vous faut donc aussi les Visual Studio C++ Build Tools (l’éditeur de liens) ; rustup-init propose de les installer s’ils sont absents. Ouvrez ensuite un nouveau terminal pour que cargo soit dans le PATH.

Linux / WSL

sudo apt install build-essential        # l'éditeur de liens C (Debian/Ubuntu ; sinon le paquet de votre distribution)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
. "$HOME/.cargo/env"                    # ou ouvrez un nouveau shell

Sous WSL, installez Rust dans la distribution Linux, pas avec l’installeur Windows, et gardez vos projets dans le système de fichiers Linux (~/src/...), pas sous /mnt/c : les builds y sont bien plus rapides. VS Code et RustRover peuvent ouvrir directement un dossier WSL.

macOS

xcode-select --install                  # les outils en ligne de commande Apple, qui incluent l'éditeur de liens
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
. "$HOME/.cargo/env"                    # ou ouvrez un nouveau terminal

Ensuite, sur n’importe quel OS :

rustc --version   # rustc 1.94.0 (4a4ef493e 2026-03-02)
cargo --version   # cargo 1.94.0 (85eff7c80 2026-01-15)
rustup update     # passer à la dernière version stable

Aucun runtime à installer

Rust compile en exécutable natif. Il n’y a ni CLR ni JVM à distribuer : le build release de « Hello, world! » est un fichier unique, d’environ 130 Ko en .exe sous Windows et d’environ 430 à 460 Ko sous macOS et Linux (mesuré par la CI du cours).

Créer un projet

cargo new hello
cd hello
cargo run

Windows

    Creating binary (application) `hello` package
   Compiling hello v0.1.0 (…\hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.01s
     Running `target\debug\hello.exe`
Hello, world!

Linux / WSL

    Creating binary (application) `hello` package
note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
   Compiling hello v0.1.0 (…/hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.55s
     Running `target/debug/hello`
Hello, world!

macOS

    Creating binary (application) `hello` package
note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
   Compiling hello v0.1.0 (…/hello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 3.89s
     Running `target/debug/hello`
Hello, world!

Les sorties Linux et macOS proviennent des runners de la CI du cours, qui utilisent un Cargo plus récent ajoutant la ligne note:.

cargo new lance aussi git init et écrit un .gitignore. L’arborescence :

hello/
├── Cargo.toml      ← like .csproj or pom.xml
├── src/
│   └── main.rs     ← entry point (a library would have src/lib.rs)
└── .gitignore

Cargo.toml

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

[dependencies]

src/main.rs

fn main() {
    println!("Hello, world!");
}

• println! se termine par ! parce que c’est une macro, pas une fonction (elle vérifie la chaîne de format à la compilation).
• L’édition (2024) joue le rôle de <LangVersion> ou de --release : elle active des changements du langage sans casser les crates plus anciennes, qui continuent de compiler avec leur propre édition.

Les sorties de ce cours

Les erreurs du compilateur et les sorties des programmes présentées dans les leçons ont été capturées sous Windows. Sous Linux et macOS, elles sont identiques aux chemins près : / au lieu de \, et pas d’extension .exe ni .dll. Chaque exemple est aussi compilé et exécuté sous Linux et macOS par la CI du cours.

Commandes du quotidien

Tâche	Cargo	dotnet	Maven
Nouvelle application	cargo new app	dotnet new console	mvn archetype:generate
Nouvelle bibliothèque	cargo new --lib lib	dotnet new classlib	—
Vérification rapide des types	cargo check	—	—
Compiler (debug)	cargo build	dotnet build	mvn compile
Compiler (release)	cargo build --release	dotnet build -c Release	mvn package
Exécuter	cargo run	dotnet run	mvn exec:java
Tester	cargo test	dotnet test	mvn test
Ajouter une dépendance	cargo add rand	dotnet add package	modifier pom.xml
Formater	cargo fmt	dotnet format	plugin Spotless
Analyser (lint)	cargo clippy	analyseurs Roslyn	Error Prone, SpotBugs
Documentation d’API	cargo doc --open	docs XML + DocFX	javadoc

Utilisez cargo check en permanence

cargo check exécute toute la vérification des types et le borrow checker, mais saute la génération de code. C’est bien plus rapide qu’un build, et c’est ce que fait votre éditeur (rust-analyzer) à chaque frappe.

Dépendances

cargo add rand

[dependencies]
rand = "0.10.2"

• "0.10.2" signifie compatible avec 0.10.2 (caret SemVer), et non « exactement 0.10.2 ».
• Les versions exactes résolues sont écrites dans Cargo.lock — comme packages.lock.json ou un fichier de verrouillage Gradle. Versionnez-le pour les applications.
• Les builds debug et release atterrissent dans target/debug et target/release (comme bin/Debug et bin/Release).

À retenir

• rustup gère les compilateurs, cargo fait tout le reste, crates.io héberge les paquets.
• Chaque OS a besoin de son éditeur de liens natif : Visual Studio Build Tools, build-essential ou les outils en ligne de commande de Xcode.
• Cargo.toml + Cargo.lock ≈ .csproj + fichier de verrouillage / pom.xml.
• cargo check pour un retour rapide, cargo build --release pour des binaires optimisés.

Exercices

1. Créez un projet nommé dice, ajoutez la crate rand, et trouvez dans Cargo.lock quelle version a réellement été résolue.

Solution

Windows

cargo new dice
cd dice
cargo add rand
cargo build
Select-String -Path Cargo.lock -Pattern 'name = "rand"' -Context 0,1

Linux / WSL

cargo new dice
cd dice
cargo add rand
cargo build
grep -A1 'name = "rand"' Cargo.lock

macOS

cargo new dice
cd dice
cargo add rand
cargo build
grep -A1 'name = "rand"' Cargo.lock

Cargo.toml contient l’exigence que vous avez demandée ; Cargo.lock contient la version exacte (et chaque dépendance transitive) qui a été choisie.

2. Quelle est la différence entre cargo check et cargo build, et quand utiliser chacun ?

Solution

cargo check vérifie les types et les emprunts sans produire de binaire, il est donc rapide — utilisez-le pendant l’édition. cargo build génère aussi le code machine — utilisez-le quand vous devez exécuter le programme, et cargo build --release pour une version optimisée.

Sources

• The Book, ch. 1 — Getting Started
• rustup — Installation et autres méthodes d’installation
• The Cargo Book — Specifying dependencies
• The Rust Edition Guide
• Microsoft — Environnement de développement Rust sous WSL