Rust-Werkzeuge und Einrichtung: alles, was du brauchst

Wenn du mit Rust anfängst, hörst du auf einmal viele neue Namen: rustup, rustc, cargo, clippy, rustfmt, rust-analyzer. Da kann man schnell das Gefühl bekommen, man bräuchte zehn Werkzeuge, bevor man eine einzige Zeile schreiben darf. Die gute Nachricht: Ein einziger Installer bringt dir fast alle davon mit. Und jedes Werkzeug hat genau eine klare Aufgabe.

Stell dir eine Küche vor. rustup ist der Laden, der deine Ausstattung liefert und austauscht. cargo ist der Koch, der alles am Laufen hält. clippy ist die freundliche Lehrerin, die dir über die Schulter schaut, und rustfmt hält die Arbeitsfläche ordentlich. Diese Seite erklärt jedes Werkzeug, was du auf deinem Betriebssystem brauchst und wie Rust-Entwickler die Tools im Alltag nutzen.

Falls du Rust noch nicht installiert hast: Die Installation Schritt für Schritt und dein erstes Projekt findest du unter Erste Schritte. Die Grundlagen von cargo (cargo new, cargo add, Cargo.toml) stehen unter Cargo und Crates. Diese Seite baut auf beiden auf.

Der Überblick

Hier ist der ganze Werkzeugkasten in einer Tabelle:

Werkzeug	Was es macht	Kommt mit rustup?
`rustup`	Installiert Rust, aktualisiert es und wechselt zwischen Versionen	Es ist der Installer
`rustc`	Der Compiler: macht aus deinen `.rs`-Dateien ein Programm	Ja
`cargo`	Baut, startet und testet dein Projekt und fügt Crates hinzu. Du nutzt es für fast alles	Ja
`rustup doc`	Öffnet die Doku der Standardbibliothek und das Rust Book offline in deinem Browser	Ja (Profil `default`)
`clippy`	Ein Linter: zeigt dir Fehler und einfachere Schreibweisen für deinen Code	Ja (Profil `default`)
`rustfmt`	Ein Formatierer: schreibt deinen Code im Standardstil neu	Ja (Profil `default`)
`rust-analyzer`	Das „Gehirn“ deines Editors: Autovervollständigung, Fehler direkt im Code, Typ-Hinweise, Sprung zur Definition	Nicht standardmäßig. Die VS-Code-Erweiterung bringt ihre eigene Kopie mit
Ein Debugger	Hält dein Programm an einer Zeile an, damit du dir die Variablen ansehen kannst	Nein. Du installierst LLDB oder GDB (oder eine Editor-Erweiterung, die einen mitbringt)

Ein Profil ist eine Gruppe von Komponenten, die rustup installiert. Die normale Installation nutzt das Profil default. Es fügt zum Compiler und zu cargo noch die Doku, clippy und rustfmt hinzu. Wenn jemand deinen Rechner mit dem Profil minimal eingerichtet hat, meldet cargo clippy, dass es nicht installiert ist. Das behebt ein einziger Befehl: rustup component add clippy rustfmt.

Probier einmal rustup doc --std aus. Der Befehl öffnet die komplette Doku der Standardbibliothek direkt von deiner Festplatte. Das klappt also auch im Flugzeug oder mit einer langsamen Verbindung. Für die Doku deines eigenen Projekts und aller Crates, die es nutzt, gibt es cargo doc --open (mehr dazu unter Dokumentation).

Vor der Installation: was jedes Betriebssystem braucht

Rust kompiliert deinen Code, braucht aber ganz am Ende einen Linker: ein Programm, das die kompilierten Teile zu einer ausführbaren Datei zusammenfügt. Rust verwendet den Linker, den die C-Werkzeuge deines Systems mitbringen. Deshalb braucht jedes Betriebssystem einen kleinen Extraschritt.

Betriebssystem	Was du installierst	Wie
Windows (empfohlen)	Die C++-Werkzeuge von Visual Studio: den MSVC-Linker und das Windows SDK	Im Visual Studio Installer die Workload Desktopentwicklung mit C++ auswählen
Windows (Alternative)	Die GNU-Toolchain (MinGW)	`rustup toolchain install stable-gnu`
Windows (noch eine Möglichkeit)	WSL, ein echtes Linux innerhalb von Windows	`wsl --install`, danach den Schritten für Linux folgen
macOS	Apples Command Line Tools (mit C-Compiler und Linker)	`xcode-select --install`
Debian / Ubuntu	Einen C-Compiler und Linker	`sudo apt install build-essential`
Fedora	Einen C-Compiler und Linker	`sudo dnf install gcc`

Ein paar ehrliche Hinweise:

Windows und Visual Studio. Du musst das nicht selbst heraussuchen: Fehlt Visual Studio, bietet rustup-init.exe an, es für dich zu installieren. Installiert wird Visual Studio Community. Das ist kostenlos für Einzelpersonen, Studierende und Open Source, aber nicht für jedes Unternehmen. Wenn du es auf der Arbeit installierst, frag nach, welche Edition deine Firma nutzt. Mit der Workload „Desktopentwicklung mit C++“ (englisch: „Desktop development with C++“) bekommst du alles, was Rust braucht.
Windows und GNU. Die MSVC-Toolchain ist der Standard und arbeitet am besten mit anderer Windows-Software zusammen. Die GNU-Toolchain kommt bei einfachen Programmen ohne Visual Studio aus. Viele Crates mit C-Code lassen sich aber erst bauen, wenn du zusätzlich MSYS2 mit MinGW installierst. Die meisten Leute sollten bei MSVC bleiben.
WSL ist eine gute Wahl, wenn du unter Windows eine Linux-Umgebung willst (zum Beispiel, weil dein Server unter Linux läuft). Innerhalb von WSL installierst du Rust mit dem normalen Linux-Befehl, getrennt von einer Windows-Installation.
Extras unter Linux. Manche beliebten Crates sprechen mit Systembibliotheken. Wenn ein Build mit einer Meldung über pkg-config oder OpenSSL fehlschlägt, installiere unter Ubuntu zusätzlich pkg-config und libssl-dev.

Danach folgst du den Installationsschritten unter Erste Schritte.

rustup in der Praxis

Sobald Rust installiert ist, kümmerst du dich mit rustup darum. Alle sechs Wochen erscheint eine neue stabile Rust-Version. Regelmäßig zu aktualisieren ist also ganz normal:

rustup update     # alle installierten Toolchains aktualisieren (und rustup selbst)
rustup show       # was installiert ist und welche Toolchain hier aktiv ist

rustup show gibt ungefähr Folgendes aus (gekürzt):

Default host: x86_64-unknown-linux-gnu

installed toolchains
--------------------
stable-x86_64-unknown-linux-gnu (active, default)

active toolchain
----------------
name: stable-x86_64-unknown-linux-gnu
active because: it's the default toolchain

Stable, beta und nightly

Eine Toolchain ist ein vollständiger Satz aus rustc, cargo und Co. Rust hat drei Release-Kanäle:

Kanal	Was er ist	Wann du ihn nutzt
stable	Das offizielle Release, alle sechs Wochen	Fast immer. Das ist das, was du willst
beta	Das nächste stabile Release, gerade in der Testphase	Du willst dein Projekt vor dem nächsten Release prüfen
nightly	Wird jede Nacht gebaut, mit experimentellen Features	Ein Tool oder Crate verlangt es, oder du willst ein neues Feature ausprobieren

Du kannst mehrere Toolchains nebeneinander installieren:

rustup toolchain install nightly   # nightly neben stable installieren
cargo +nightly build               # nightly nur für diesen einen Befehl nutzen
rustup default stable              # festlegen, welche Toolchain überall verwendet wird

Eine Toolchain pro Projekt festlegen

Manchmal braucht ein Projekt eine bestimmte Rust-Version. Leg dann eine Datei namens rust-toolchain.toml in den Projektordner. rustup wechselt automatisch, sobald du in diesem Ordner arbeitest:

[toolchain]
channel = "1.97.0"
components = ["clippy", "rustfmt"]
targets = ["wasm32-unknown-unknown"]

Committe diese Datei in Git. Dann nutzen alle in deinem Team (und deine CI) genau denselben Compiler, und rustup installiert ihn automatisch, falls er fehlt. Die meisten kleinen Projekte brauchen diese Datei überhaupt nicht. Sie nehmen einfach das neueste stable.

Komponenten und Targets

Komponenten sind zusätzliche Teile einer Toolchain. Mit Targets (Zielplattformen) kompilierst du für eine andere Art von Rechner:

rustup component add clippy rustfmt rust-src   # rust-src: Quellcode von std, wird von rust-analyzer genutzt
rustup component list --installed              # anzeigen, was du hast
rustup target add wasm32-unknown-unknown       # Rust für den Browser kompilieren

Das Target wasm32-unknown-unknown brauchst du für WebAssembly.

Editoren und IDEs

Du kannst Rust in jedem Texteditor schreiben. Ein Editor mit rust-analyzer (oder einer ähnlichen Engine) macht aber einen riesigen Unterschied: Du siehst Fehler schon beim Tippen, die Typen deiner Variablen stehen direkt daneben, und du springst mit einem Klick zur Definition jeder Funktion. Für Anfänger ist dieses Feedback wie ein geduldiger Nachhilfelehrer.

Editor	Preis	Rust-Unterstützung	Gut für
VS Code + rust-analyzer	Kostenlos	Offizielle rust-analyzer-Erweiterung	Die meisten Leute. Es ist die beliebteste Wahl, und die meisten Anleitungen gehen davon aus
RustRover (JetBrains)	Kostenlos für nicht-kommerzielle Nutzung (Lernen, Hobbyprojekte, unbezahltes Open Source). Für kommerzielle Arbeit brauchst du ein kostenpflichtiges Abo	Eingebaut, mit JetBrains’ eigener Rust-Engine und eingebautem Debugger	Leute, die eine vollständige IDE mit allem Drum und Dran mögen
Zed	Kostenlos, Open Source	Eingebaut (nutzt rust-analyzer und zum Debuggen CodeLLDB)	Einen sehr schnellen, modernen Editor
Neovim / Helix	Kostenlos, Open Source	Über rust-analyzer. Helix funktioniert fast sofort; Neovim braucht etwas Konfiguration	Leute, die gern im Terminal arbeiten
Visual Studio	Kostenpflichtige Editionen, dazu die kostenlose Community-Edition	Keine offizielle Rust-Unterstützung	Passt nicht gut zu Rust. Du brauchst nur seine C++ Build Tools für den Linker

Die Lizenzbedingungen von RustRover können sich ändern. Schau deshalb auf der RustRover-Seite (auf Englisch) nach den aktuellen Regeln, bevor du es auf der Arbeit nutzt.

Für Neovim, Helix und andere Editoren installierst du das Programm rust-analyzer selbst mit rustup component add rust-analyzer.

Empfohlene Erweiterungen für VS Code

Wenn du VS Code nutzt, decken diese vier Erweiterungen fast alles ab:

rust-analyzer – die wichtigste: Vervollständigung, Fehler, Hinweise, Refactoring.
CodeLLDB – ein Debugger für Breakpoints und schrittweises Durchgehen deines Codes. Er bringt seine eigene Kopie von LLDB mit.
Even Better TOML – färbt und prüft deine Cargo.toml.
Error Lens (optional) – zeigt Fehlermeldungen direkt in der Zeile an, nicht erst, wenn du mit der Maus darüberfährst. Manche lieben das, anderen ist es zu unruhig.

Debugging

Breakpoints mit CodeLLDB

Wenn rust-analyzer und CodeLLDB in VS Code installiert sind, siehst du kleine Links Run | Debug über fn main und über jedem Test. Klick links neben eine Zeilennummer, um einen roten Breakpoint-Punkt zu setzen, und dann auf Debug. Das Programm hält an deinem Breakpoint an. Jetzt kannst du dir jede Variable ansehen und den Code Zeile für Zeile durchgehen.

Wenn du eine wiederverwendbare Konfiguration willst (zum Beispiel, um Kommandozeilenargumente zu übergeben), leg die Datei .vscode/launch.json an:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "lldb",
      "request": "launch",
      "name": "Debug task_queue",
      "cargo": {
        "args": ["build", "--bin=task_queue"]
      },
      "args": [],
      "cwd": "${workspaceFolder}"
    }
  ]
}

Der Teil cargo sagt CodeLLDB, dass es dein Programm zuerst mit cargo bauen und dann im Debugger starten soll. Ersetze task_queue durch den Namen deines Pakets und schreib Programmargumente in "args". Mit F5 geht es los.

Schnelle Checks mit `dbg!`

Du brauchst nicht immer einen kompletten Debugger. Das Makro dbg! gibt einen Ausdruck aus, dazu seinen Wert und die Datei und Zeile, in der du es geschrieben hast. Außerdem gibt es den Wert zurück. Du kannst es also um fast alles herumlegen, ohne zu ändern, was dein Code tut:

fn apply_discount(price: u32, percent: u32) -> u32 {
    price - price * percent / 100
}

fn main() {
    let prices = [120, 45, 80];

    let total: u32 = dbg!(prices.iter().sum());
    let final_price = dbg!(apply_discount(total, 10));

    println!("Gesamtpreis mit 10 % Rabatt: {final_price}");
}

Ausgabe:

Gesamtpreis mit 10 % Rabatt: 221

▶ Selbst ausprobieren

Wo sind die Zeilen von dbg! geblieben? dbg! schreibt nach stderr (den Fehlerkanal), nicht nach stdout wie println!. So bleiben deine Debug-Notizen von der eigentlichen Ausgabe getrennt. In deinem Terminal oder im Bereich „Standard Error“ des Playgrounds siehst du zusätzlich:

[src/main.rs:8:22] prices.iter().sum() = 245
[src/main.rs:9:23] apply_discount(total, 10) = 221

Entferne deine dbg!-Aufrufe, wenn du fertig bist. Sie sind für dich da, nicht für deine Nutzer.

Codequalität im Alltag

Drei Befehle halten deinen Code gesund. Sie sind schnell, also führ sie oft aus.

`cargo check`: schnelles Feedback

cargo check findet Compilerfehler, ohne ein ausführbares Programm zu bauen. Deshalb ist es viel schneller als cargo build. Viele Entwickler führen es alle paar Minuten aus. (Der rust-analyzer in deinem Editor macht so einen Check sowieso bei jedem Speichern für dich.)

`cargo fmt`: nie wieder Streit über den Stil

cargo fmt schreibt jede Datei in deinem Projekt im Standardstil von Rust neu. Niemand in deinem Team muss je wieder über Leerzeichen oder Zeilenumbrüche nachdenken. Aus diesem Code:

struct Player{name:String,score:u32}
fn top(players:&[Player])->Option<&Player>{players.iter().max_by_key(|p|p.score)}

wird dieser:

struct Player {
    name: String,
    score: u32,
}
fn top(players: &[Player]) -> Option<&Player> {
    players.iter().max_by_key(|p| p.score)
}

Die meisten Editoren können das bei jedem Speichern erledigen. In VS Code schaltest du dafür die Einstellung „Format On Save“ ein.

`cargo clippy`: ein freundliches Code-Review

Clippy kennt Hunderte Muster, die falsch, langsam oder einfach schwerer zu lesen sind als nötig. Hier ist ein kleines Programm, das einwandfrei funktioniert:

fn main() {
    let tasks: Vec<&str> = vec!["Doku schreiben", "Bug beheben"];

    if tasks.len() == 0 {
        println!("Nichts zu tun!");
    } else {
        println!("{} Aufgaben warten", tasks.len());
    }
}

Aber cargo clippy hat einen Vorschlag:

warning: length comparison to zero
 --> src/main.rs:4:8
  |
4 |     if tasks.len() == 0 {
  |        ^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `tasks.is_empty()`
  |
  = note: `#[warn(clippy::len_zero)]` on by default

Clippy meldet sich auf Englisch. Gemeint ist: Statt die Länge mit null zu vergleichen, ist tasks.is_empty() klarer. Jede Warnung hat einen Namen (hier len_zero), den du in der Liste der Clippy-Lints (auf Englisch) nachschlagen kannst, um eine ausführlichere Erklärung zu bekommen. Hier ist die korrigierte Version:

fn main() {
    let tasks: Vec<&str> = vec!["Doku schreiben", "Bug beheben"];

    if tasks.is_empty() {
        println!("Nichts zu tun!");
    } else {
        println!("{} Aufgaben warten", tasks.len());
    }
}

Ausgabe:

2 Aufgaben warten

▶ Selbst ausprobieren

cargo clippy --fix kann viele Vorschläge automatisch für dich übernehmen. Clippy liegt nicht in jeder Situation richtig. Aber oft genug, dass du schnell idiomatisches Rust lernst, wenn du jede Warnung liest.

Nützliche zusätzliche cargo-Tools

Jeder kann neue cargo-Unterbefehle bauen. Du installierst sie mit cargo install. Der Befehl lädt den Quellcode herunter, kompiliert ihn und legt das Programm in ~/.cargo/bin ab (unter Windows in %USERPROFILE%\.cargo\bin). Am ersten Tag brauchst du keins davon, aber es lohnt sich, sie zu kennen:

Tool	Was es macht	Installieren	Ausführen
bacon	Führt check, clippy oder die Tests bei jedem Speichern neu aus, in einem Terminal nebenher	`cargo install --locked bacon`	`bacon`, `bacon clippy`, `bacon test`
cargo-watch	Führt beim Speichern einen beliebigen cargo-Befehl aus. Funktioniert noch, wird aber nicht mehr weiterentwickelt; der Autor empfiehlt bacon	`cargo install --locked cargo-watch`	`cargo watch -x check`
cargo-nextest	Ein schnellerer Test-Runner mit übersichtlicherer Ausgabe	`cargo install --locked cargo-nextest`	`cargo nextest run`
cargo-audit	Prüft deine `Cargo.lock` auf bekannte Sicherheitslücken	`cargo install cargo-audit`	`cargo audit`
cargo-outdated	Listet Abhängigkeiten auf, für die es neuere Versionen gibt	`cargo install --locked cargo-outdated`	`cargo outdated`
cargo-edit	Fügt `cargo upgrade` hinzu, das die Versionen in `Cargo.toml` anhebt (`cargo add` ist schon eingebaut)	`cargo install cargo-edit`	`cargo upgrade`
cargo-expand	Zeigt den Code, zu dem deine Makros und `#[derive]`s werden	`cargo install cargo-expand`	`cargo expand`
cargo-binstall	Lädt fertige Binärdateien herunter, statt zu kompilieren. Installationen dauern so nur Sekunden	`cargo install cargo-binstall`	`cargo binstall bacon`

cargo install kompiliert aus dem Quellcode. Die erste Installation eines großen Tools kann deshalb ein paar Minuten dauern. Das ist normal. Um ein Tool später zu aktualisieren, führst du denselben Installationsbefehl einfach noch einmal aus. Was du installiert hast, zeigt dir cargo install --list. Tools rund um Geschwindigkeit, etwa Profiler und Benchmarks, findest du unter Performance.

Ganz ohne Installation: der Rust Playground

Der Rust Playground führt Rust direkt in deinem Browser aus. Jeder Button „Selbst ausprobieren“ auf dieser Seite öffnet ihn. Er ist perfekt für schnelle Experimente, um ein Code-Schnipsel zu teilen, wenn du um Hilfe bittest, oder um an einem Rechner zu lernen, auf dem du nichts installieren darfst.

Was er kann:

Deinen Code mit stable, beta oder nightly ausführen, als Debug- oder Release-Build.
Die 100 am häufigsten heruntergeladenen Crates von crates.io nutzen (dazu die Crates aus dem Rust Cookbook und deren Abhängigkeiten), zum Beispiel serde, rand, regex und tokio.
rustfmt und Clippy über das Menü Tools ausführen.
Deinen Code als Link teilen.

Was er nicht kann:

Mehr als eine Datei haben. Es gibt keine Cargo.toml, du kannst also keine anderen Crates oder Versionen auswählen.
Aufs Netzwerk zugreifen. Code, der eine Webseite herunterlädt, schlägt fehl.
Mit deinen eigenen Dateien arbeiten oder lange laufen. Zeit und Speicher sind begrenzt.
Bequem interaktive Programme ausführen. Während ein Programm läuft, kannst du zwar in ein kleines Feld Eingaben tippen. Für mehr als einen kurzen Test ist das aber umständlich. Die Beispiele auf dieser Seite lesen nie Eingaben ein, deshalb laufen sie mit einem Klick.

Wenn er dir zu klein wird, ist ein lokales Projekt mit cargo new nur eine Minute entfernt.

Checkliste für einen neuen Rechner

Du richtest einen neuen Computer ein? Geh diese Liste einmal durch:

Installiere die Voraussetzungen für dein Betriebssystem: die C++-Werkzeuge von Visual Studio (Windows), xcode-select --install (macOS) oder build-essential / gcc (Linux).
Installiere Rust über rustup.rs und öffne danach ein neues Terminal.
Prüf die Installation: rustc --version und cargo --version.
Stell sicher, dass die Alltagswerkzeuge da sind: rustup component add clippy rustfmt.
Installiere einen Editor mit rust-analyzer. In VS Code fügst du die Erweiterungen rust-analyzer und CodeLLDB hinzu.
Schalte in deinem Editor das Formatieren beim Speichern ein.
Leg mit cargo new hello ein Testprojekt an und führ darin cargo run, cargo clippy und cargo fmt aus.
Stell dir eine Erinnerung, alle ein bis zwei Monate rustup update auszuführen.
Optional: cargo install --locked bacon für sofortiges Feedback beim Programmieren.

Übungen

1. Prüf deinen Werkzeugkasten

Führ auf deinem eigenen Rechner jeden dieser Befehle aus und achte darauf, dass keiner „not installed“ (nicht installiert) meldet: rustup show, cargo clippy --version, cargo fmt --version. Öffne dann die Offline-Doku der Standardbibliothek und such die Seite zu Vec. Tipp: rustup doc nimmt ein Thema entgegen, zum Beispiel den vollständigen Pfad eines Typs.

Lösung anzeigen

rustup show
cargo clippy --version
cargo fmt --version
rustup doc std::vec::Vec

Jeder --version-Befehl gibt eine Versionsnummer aus. Zeigt einer stattdessen einen Fehler, installierst du das fehlende Teil mit rustup component add clippy oder rustup component add rustfmt. Der letzte Befehl öffnet die Seite zu Vec in deinem Browser, direkt von deiner Festplatte. Meldet er, dass rust-docs nicht installiert ist, führ zuerst rustup component add rust-docs aus.

2. Lass dich von Clippy unterrichten

Kopiere in einem neuen Projekt die erste Version des Aufgabenprogramms aus dem Abschnitt über Clippy in src/main.rs. Führ cargo clippy aus, lies die Warnung und lass Clippy sie dann für dich beheben. Tipp: Es gibt ein Flag, das die Vorschläge automatisch übernimmt.

Lösung anzeigen

cargo new task_queue
cd task_queue
# Programm in src/main.rs einfügen, dann:
cargo clippy
cargo clippy --fix --allow-dirty
cargo clippy

Der erste Aufruf von cargo clippy zeigt die Warnung len_zero. cargo clippy --fix macht aus tasks.len() == 0 dann tasks.is_empty(). Mit dem Flag --allow-dirty darf es auch Dateien ändern, die du noch nicht in Git committet hast. Der letzte Aufruf zeigt keine Warnungen mehr.

Zusammenfassung

rustup installiert und aktualisiert Rust und wechselt zwischen Toolchains. cargo baut, startet und testet dein Projekt und fügt Crates hinzu. rustc ist der Compiler darunter.
Jedes Betriebssystem braucht zuerst einen Linker: die C++-Werkzeuge von Visual Studio unter Windows, xcode-select --install unter macOS, build-essential oder gcc unter Linux.
Bleib bei stable. Nimm rust-toolchain.toml nur, wenn ein Projekt eine Version festschreiben muss, und cargo +nightly für einzelne nightly-Befehle.
Nutze einen Editor mit rust-analyzer. VS Code mit rust-analyzer und CodeLLDB ist die verbreitetste Einrichtung.
Führ cargo check oft aus und vor jedem Commit cargo fmt und cargo clippy. Nimm dbg! für einen schnellen Blick und einen Debugger für hartnäckigere Fehler.
Der Playground ist super zum Experimentieren und Teilen. Aber er kennt nur eine Datei, hat kein Netzwerk und nur die beliebtesten Crates.

Kurzer Check

1. Mit welchem Werkzeug installierst du die nightly-Toolchain neben stable?

2. Dein Build unter Windows schlägt fehl, weil kein Linker gefunden wird. Was fehlt wahrscheinlich?

3. Wohin schreibt dbg! seine Ausgabe?

4. Was kann der Rust Playground NICHT?

Punkte: 0 / 4

Weiterlesen

Install Rust – rust-lang.org (auf Englisch): der offizielle Installer für jede Plattform, dazu Hinweise zu Windows, PATH und zur Deinstallation.
The rustup book (auf Englisch): Toolchains, Kanäle, Komponenten, Profile, rust-toolchain.toml und Targets für Cross-Kompilierung.
The Cargo Book (auf Englisch): alles über cargo, auch über cargo install und die Optionen jedes Befehls.
rust-analyzer manual (auf Englisch): rust-analyzer in VS Code, Neovim, Helix, Emacs und weiteren Editoren einrichten, mit allen Einstellungen.
Clippy-Dokumentation (auf Englisch): wie du Clippy ausführst und konfigurierst, mit einem Link zur vollständigen Liste der Lints und ihrer Bedeutung.