Installation mit rustup

Warum rustup statt System-Paket?

Auf den ersten Blick wirkt es unnötig: Debian, Ubuntu, Fedora und Homebrew haben alle ein rust-Paket. Warum dann noch ein eigener Installer?

Drei Gründe — alle drei wirst du irgendwann zu spüren bekommen:

• System-Pakete hinken Wochen bis Monate hinterher. Rust hat einen sechswöchigen Release-Zyklus. Distributions-Pakete sind dafür nicht gebaut — Debian Stable liefert teils Rust-Versionen, die anderthalb Jahre alt sind. Crates auf crates.io setzen aber regelmäßig recht aktuelle Compiler voraus.
• Du brauchst oft mehrere Toolchains gleichzeitig. Ein Projekt nutzt stable, ein anderes braucht nightly für ein experimentelles Feature, ein drittes ist auf einer fixen Rust-Version gepinnt. rustup verwaltet das nebeneinander, ohne dass du irgendwo update-alternatives jonglierst.
• Komponenten und Targets gehören dazu. rust-analyzer, clippy, rustfmt, miri, plus Cross-Compile-Bibliotheken für jedes Target — alles ein rustup component add oder rustup target add entfernt. Das ist in System-Paketen häufig zersplittert oder gar nicht verfügbar.

Die einzige sinnvolle Ausnahme: vollständig containerisierte Builds (Docker-Image mit einer fixen Rust-Version). Selbst dort verwenden die offiziellen Rust-Images intern wieder rustup.

Was rustup eigentlich ist

rustup ist kein Compiler. Es ist ein Werkzeug, das Compiler installiert und verwaltet. Wenn du rustup install stable aufrufst, lädt es einen vorgebauten Compiler von forge.rust-lang.org herunter, packt ihn in ~/.rustup/toolchains/stable-x86_64-unknown-linux-gnu/ und legt Wrapper unter ~/.cargo/bin/ an.

Die Wrapper sind der Trick: ~/.cargo/bin/cargo ist nur ein winziges Programm, das anhand der aktuellen Konfiguration entscheidet, welche Toolchain es aufruft. Welche „aktuelle Konfiguration"? Drei Quellen, in absteigender Priorität:

1. +toolchain-Argument auf der Kommandozeile: cargo +nightly build.
2. rust-toolchain.toml im Projekt-Verzeichnis (oder einem Eltern-Verzeichnis).
3. Default-Toolchain aus rustup default.

Das bedeutet: ein Projekt mit rust-toolchain.toml = { channel = "1.78" } zwingt jeden, der dort cargo build ausführt, exakt diese Rust-Version zu nutzen — rustup zieht sie nötigenfalls beim ersten Aufruf nach.

Installation auf macOS und Linux

Auf macOS und Linux ist die Installation eine einzige Zeile von rustup.rs:

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

Der Installer fragt dich interaktiv nach:

• Welcher Channel — stable ist der Default. Stable nehmen, außer du weißt, dass du nightly brauchst.
• Welche Host-Triple — wird normalerweise korrekt erkannt (aarch64-apple-darwin, x86_64-unknown-linux-gnu, ...).
• PATH-Modifikation — sagt Yes; sonst musst du source $HOME/.cargo/env von Hand machen.

Nach der Installation entweder neue Terminal-Session öffnen oder einmalig die Umgebung laden:

source "$HOME/.cargo/env"
rustc --version

Die letzte Zeile sollte etwas wie rustc 1.82.0 (f6e511eec 2024-10-15) ausgeben — mit der aktuellen Versionsnummer zum Zeitpunkt der Installation.

Was wird wohin installiert?

• ~/.rustup/ — alle Toolchains, jede in einem eigenen Unterordner.
• ~/.cargo/ — der Cargo-Cache (bin/, registry/, git/). Die Wrapper-Binaries (cargo, rustc, rustup) liegen in ~/.cargo/bin/.
• Kein Schreibzugriff auf System-Verzeichnisse. Alles bleibt im Home-Verzeichnis des Users.

Voraussetzungen — der Linker

rustup bringt den Rust-Compiler mit, aber nicht den Linker. Den brauchst du fürs Erzeugen ausführbarer Programme. Je nach Plattform:

• macOS — xcode-select --install einmal ausführen (lädt die Command Line Tools mit clang und ld).
• Linux — auf Debian/Ubuntu: sudo apt install build-essential. Auf Fedora: sudo dnf groupinstall 'Development Tools'. Auf Arch: sudo pacman -S base-devel.

Fehlt der Linker, scheitert dein erstes cargo build mit einer Meldung der Sorte error: linker 'cc' not found — der Hinweis ist eindeutig, der Reflex aber gerne erstmal Rust zu beschuldigen.

Installation auf Windows

Windows ist etwas mehr Fingerarbeit, weil du dich für eine ABI entscheiden musst:

• MSVC (Microsoft Visual C++) — der Standard. Benötigt die Visual Studio Build Tools (kostenlos), die unter anderem link.exe mitbringen.
• GNU (MinGW-w64) — alternativ, ohne Visual-Studio-Abhängigkeit. Geringere Performance, weniger gut getestet, manche Crates funktionieren nicht.

In den meisten Fällen die richtige Wahl: MSVC. Vorgehensweise:

1. Visual Studio Build Tools installieren. Vom Microsoft-Download die „Build Tools for Visual Studio" herunterladen. Im Installer „Desktop development with C++" auswählen — das genügt, du brauchst kein vollständiges Visual Studio.
2. rustup-init.exe von rustup.rs herunterladen und ausführen.
3. Default-Toolchain bestätigen (stable-x86_64-pc-windows-msvc).

Danach das Terminal (PowerShell oder Windows Terminal) neu öffnen und rustc --version prüfen.

Stolperfalle: Antivirus

Windows-Defender und Drittanbieter-Antivirus scannen ~/.cargo/registry/ und target/-Ordner gerne intensiv. Das macht Builds zwei- bis dreimal langsamer. Empfohlene Excludes:

• %USERPROFILE%\.cargo
• %USERPROFILE%\.rustup
• Pro Projekt: dessen target\-Ordner

In Defender unter „Virus & threat protection settings" → „Exclusions" zu setzen.

Stolperfalle: Pfade mit Leerzeichen oder Umlauten

Cargo geht damit eigentlich um — manche älteren Crates, gerade solche mit eigenen build.rs-Skripten, stolpern aber bei Pfaden wie C:\Benutzer\Müller\projects\…. Wenn es seltsame Fehler beim Build gibt: erst auf einem Pfad ohne Sonderzeichen testen.

Channels: stable, beta, nightly

rustup unterscheidet drei Release-Linien:

Eine konkrete Version kannst du auch direkt installieren: rustup install 1.78 zieht exakt diese Toolchain.

Wechseln und prüfen

rustup show                          # Welche Toolchain ist aktiv?
rustup install nightly               # Nightly nachinstallieren
rustup default stable                # Stable als globalen Default setzen
rustup update                        # Alle installierten Toolchains updaten

cargo +nightly build                 # Einmal mit Nightly bauen, ohne den Default zu ändern

rustup show listet auch alle installierten Toolchains und welche aktiv ist — der erste Befehl bei jedem „bei mir geht's nicht"-Problem.

Projektbezogene Toolchains

Lege im Projekt-Root eine rust-toolchain.toml an:

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

Jeder, der in diesem Verzeichnis cargo aufruft, nutzt automatisch genau diese Toolchain. rustup zieht sie beim ersten Aufruf nach, wenn sie noch nicht installiert ist. Sehr nützlich für Reproduzierbarkeit in Teams.

Alternativ — älter, aber noch unterstützt — eine rust-toolchain-Datei (ohne Endung) mit nur dem Channel-Namen darin.

Komponenten

Eine Toolchain besteht aus Bausteinen, die du einzeln dazuholen kannst:

rustup component list --installed        # Was habe ich?
rustup component add rust-analyzer       # rust-analyzer nachinstallieren
rustup component add llvm-tools-preview  # LLVM-Tools
rustup component remove miri             # Wieder loswerden

Bei stable-Installationen sind rustfmt, clippy und rust-analyzer heute meistens standardmäßig dabei — auf älteren Setups oder bei manuellen Installationen lohnt der Check mit rustup component list --installed.

Cross-Compile-Targets

Ein Target ist die Plattform, für die du Code erzeugst — unabhängig davon, auf welcher du baust.

rustup target list                                # Alle möglichen
rustup target list --installed                    # Aktuell installierte
rustup target add x86_64-unknown-linux-musl       # Statisches Linux-Binary
rustup target add wasm32-unknown-unknown          # WebAssembly
rustup target add aarch64-unknown-linux-gnu       # 64-Bit ARM Linux

cargo build --release --target wasm32-unknown-unknown

Was rustup hier nachinstalliert, ist die vorgebaute Standard-Library für das jeweilige Target. Den Linker für fremde Plattformen bringt es nicht mit — für echtes Cross-Linking nutzt man oft das cross-Tool, das den Build in einem passenden Docker-Container ausführt.

Update, Diagnose, Deinstallation

rustup update                       # Alle installierten Toolchains aktualisieren
rustup update stable                # Nur stable
rustup self update                  # rustup selbst aktualisieren

rustup which cargo                  # Pfad zum aktuell aktiven cargo
rustup doc                          # Offline-Doku im Browser öffnen
rustup doc --book                   # Direkt das Rust Book

rustup self uninstall               # Alles wieder entfernen (~/.rustup, ~/.cargo/bin/*)

Bei der Deinstallation bleiben ~/.cargo/registry/ und projektlokale target/-Ordner erhalten — wer wirklich alles loswerden will, löscht das Cargo-Home anschließend manuell.

Weiterführende Ressourcen

Externe Quellen

• rustup.rs – offizielle Installer-Seite
• The rustup book
• Rust Forge – Platform Support
• Rust Releases – stable Channel
• Visual Studio Build Tools – Microsoft Download
• cross – Cross-Compilation über Docker

Verwandte Artikel

• Was ist Rust?
• Grundlagen-Übersicht