Erste Schritte mit Rust

Lass uns Rust auf deinem Rechner zum Laufen bringen und dein erstes Programm bauen. Wenn du noch nichts installieren möchtest, kannst du auch im Rust Playground mitmachen und später auf diese Seite zurückkommen.

Schritt 1: Rust mit rustup installieren

Der offizielle Weg, Rust zu installieren, ist ein Tool namens rustup. Es installiert den Rust-Compiler und das Build-Tool cargo und hält alles auf dem neuesten Stand.

Geh auf rustup.rs und folge der Anleitung für dein System:

• Windows – lade rustup-init.exe herunter, führe es aus und übernimm die Standardoptionen.

• macOS / Linux – füg diesen Befehl in dein Terminal ein:

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

Hinweis

Unter Windows braucht Rust die C++-Build-Tools. Wenn der Installer danach fragt, lass ihn die „Visual Studio C++ Build Tools“ installieren. Rust verwendet sie, um deine Programme zu linken.

Schritt 2: Prüfen, ob alles geklappt hat

Schließ dein Terminal, öffne es neu und führe dann Folgendes aus:

rustc --version
cargo --version

Du solltest Versionsnummern wie rustc 1.xx.0 sehen. Wenn ja, kann es losgehen.

• rustc ist der Rust-Compiler (er macht aus deinem Code ein ausführbares Programm).
• cargo ist das Rundum-Werkzeug von Rust: Damit baust, startest und testest du Projekte und verwaltest sie. Du wirst cargo für fast alles benutzen.

Schritt 3: Dein erstes Projekt anlegen

Statt Dateien von Hand anzulegen, lässt du cargo ein Projekt für dich einrichten:

cargo new hello_rust
cd hello_rust

Das erstellt einen Ordner namens hello_rust mit allem, was ein Rust-Projekt braucht:

hello_rust/
├── Cargo.toml      # Projekteinstellungen und Abhängigkeiten
└── src/
    └── main.rs     # hier kommt dein Code hin

• Cargo.toml beschreibt dein Projekt (Name, Version und die Bibliotheken, die es verwendet).
• src/main.rs ist die Startdatei – cargo schreibt dir sogar schon ein Hello World hinein.

Schritt 4: Ausführen

Führ im Projektordner diesen Befehl aus:

cargo run

Du siehst, wie cargo das Projekt kompiliert, und dann erscheint:

Hello, world!

Das war’s – du hast gerade ein Rust-Programm gebaut und ausgeführt. (Die Meldung ist auf Englisch, weil cargo sie standardmäßig so anlegt.)

Den Code verstehen

Öffne src/main.rs. Dort findest du:

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

• fn main() { ... } definiert die main-Funktion (Hauptfunktion). Jedes Rust-Programm startet hier.
• println!("...") gibt eine Zeile Text auf dem Bildschirm aus.

Ändere die Nachricht und führe cargo run noch einmal aus:

fn main() {
    println!("Hallo aus meinem ersten Rust-Programm!");
}

Ausgabe:

Hallo aus meinem ersten Rust-Programm!

▶ Selbst ausprobieren

cargo run oder cargo build?

Zwei Befehle, die du ständig brauchen wirst:

Befehl	Was er macht
cargo run	Kompiliert und startet dein Programm (ideal beim Entwickeln)
cargo build	Kompiliert nur – das Programm landet in target/debug/
cargo build --release	Kompiliert eine optimierte, schnellere Version für die Auslieferung

Wenn etwas schiefgeht: Compiler-Fehler lesen

Du wirst Compiler-Fehler sehen – jeden Tag, auch nach Jahren mit Rust. Das heißt nicht, dass du schlecht darin bist. Der Compiler macht einfach seinen Job. Bauen wir absichtlich einen Fehler ein, damit er beim ersten Mal weniger erschreckt.

Entferne das ! aus println! in src/main.rs:

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

Führe cargo run aus, und du bekommst:

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

Lies die Meldung von oben nach unten:

1. Die erste Zeile sagt, was falsch ist: Rust hat eine Funktion erwartet, aber println ist ein Makro (was das bedeutet, lernst du auf der nächsten Seite).
2. --> src/main.rs:2:5 sagt dir, wo: Datei src/main.rs, Zeile 2, Spalte 5.
3. Die Markierung ^^^^^^^ zeigt auf genau die betroffene Stelle im Code.
4. Der Teil help: zeigt oft schon die Lösung. Hier markiert er das fehlende ! sogar mit einem +.

Setz das ! wieder ein, und alles funktioniert wieder:

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

Ausgabe:

Hello, world!

▶ Selbst ausprobieren

Schneller prüfen

cargo check sucht nach Fehlern, ohne ein ausführbares Programm zu bauen. Bei größeren Projekten ist das viel schneller als cargo build. Darum lassen viele es beim Schreiben ständig laufen. Auch nach dem Code E0423 kannst du suchen: rustc --explain E0423 gibt eine längere Erklärung mit Beispielen aus (auf Englisch).

Schritt 5: Deinen Editor einrichten (empfohlen)

Am angenehmsten arbeitest du mit der Erweiterung rust-analyzer in deinem Editor. Sie bietet dir Autovervollständigung, Fehlermeldungen direkt im Code und Typhinweise, während du tippst.

• VS Code – installiere die rust-analyzer-Erweiterung
• Die meisten anderen Editoren (JetBrains, Neovim usw.) unterstützen rust-analyzer ebenfalls.

Tipp

Behalte die Fehlermeldungen des Compilers beim Lernen im Blick. Die Fehler von Rust sind berühmt dafür, hilfreich zu sein. Meistens erklären sie, was schiefgelaufen ist und wie du es behebst.

Übungen

1. Drei Zeilen

Lass dein Programm drei Zeilen ausgeben: deinen Namen, dein Lieblingsessen und Ich habe gerade Rust ausgeführt!. Tipp: Ein println! gibt eine Zeile aus – du brauchst also drei davon.

Lösung anzeigen

fn main() {
    println!("Ich heiße Sam");
    println!("Ich mag Pizza");
    println!("Ich habe gerade Rust ausgeführt!");
}

Ausgabe:

Ich heiße Sam
Ich mag Pizza
Ich habe gerade Rust ausgeführt!

▶ Selbst ausprobieren

2. Ein kleines Banner

Gib ein kleines Banner wie das unten aus: einen Titel mit einer Zeile aus =-Zeichen darüber und darunter. Mach es dann absichtlich kaputt, indem du ein ! löschst. Führe cargo run aus, lies den Fehler und behebe ihn. Tipp: Die =-Zeilen sind einfach Text in println!, wie jede andere Nachricht auch.

Lösung anzeigen

fn main() {
    println!("==============");
    println!("  HALLO RUST");
    println!("==============");
}

Ausgabe:

==============
  HALLO RUST
==============

▶ Selbst ausprobieren

Zusammenfassung

• Installiere Rust mit rustup von rustup.rs.
• Prüfe die Installation mit rustc --version und cargo --version.
• Leg ein Projekt mit cargo new an und starte es mit cargo run.
• Ein Projekt hat eine Cargo.toml (Einstellungen) und eine src/main.rs (dein Code).
• Lies Compiler-Fehler von oben nach unten: was, wo – und oft ein help: mit der Lösung.
• Installiere rust-analyzer in deinem Editor – damit geht alles viel leichter.

Kurzer Check

Kurzer Check

1. Welches Tool installiert den Rust-Compiler und cargo und hält beide aktuell?

rustup cargo rustc

2. Welche Datei beschreibt Name, Version und Abhängigkeiten eines Rust-Projekts?

src/main.rs target/debug/ Cargo.toml

3. Welcher Befehl kompiliert dein Programm nur, ohne es auszuführen?

cargo run cargo build cargo new

Punkte: 0 / 3

Weiterlesen

• Installation – Die Programmiersprache Rust: Installation auf allen Plattformen, Aktualisieren mit rustup update und Fehlerbehebung.
• Hallo Cargo! – Die Programmiersprache Rust: ein genauerer Blick auf cargo new, cargo build, cargo run und cargo check.
• First Steps with Cargo – The Cargo Book (auf Englisch): was cargo new anlegt und was jede Zeile in Cargo.toml bedeutet.
• The rustup book (auf Englisch): zusätzliche Toolchains installieren, Rust aktualisieren und zwischen Stable und Nightly wechseln.
• rust-analyzer (auf Englisch): Anleitungen zur Einrichtung für VS Code, Neovim, Emacs und andere Editoren.