Rust programmieren mit Visual Studio Code – Einstieg für Anfänger

Du möchtest die Programmiersprache Rust lernen, hast aber noch nie mit Visual Studio Code (VS Code) gearbeitet? In dieser Anleitung richten wir eine kostenlose Entwicklungsumgebung ein, lernen die wichtigsten Bereiche von VS Code kennen und schreiben unser erstes Rust-Programm. Vorkenntnisse sind nicht erforderlich.

Voraussetzungen: Windows oder Linux (z. B. Zorin OS), Internetverbindung für die Installation und die Berechtigung, Programme auf deinem PC zu installieren.

1. Was ist Rust?

Rust ist eine moderne, quelloffene Programmiersprache. Sie eignet sich für schnelle und zuverlässige Anwendungen: Kommandozeilenprogramme, Desktop-Software, Webserver und auch Mikrocontroller wie den Raspberry Pi Pico.

Anders als Python wird Rust-Code vor dem Start kompiliert, also in ausführbaren Maschinencode übersetzt. Dabei erkennt der Compiler viele Fehler frühzeitig. Ein besonderes Merkmal ist das Ownership-System zur sicheren Speicherverwaltung. Das behandeln wir später ausführlich im Grundlagenkurs.

2. Was ist Visual Studio Code?

Visual Studio Code ist ein kostenloser, erweiterbarer Code-Editor von Microsoft. Du kannst darin Dateien bearbeiten, Projekte verwalten, Terminalbefehle ausführen und Programme debuggen.

VS Code ist nicht dasselbe wie Visual Studio. Für unsere Rust-Beispiele genügt VS Code.

Offizielle Website: https://code.visualstudio.com/

3. Welche Programme werden benötigt?

Cargo wird zusammen mit Rust über rustup installiert.

4. Rust unter Windows installieren

1. Öffne https://rustup.rs/ und lade das offizielle Windows-Installationsprogramm herunter.
2. Starte die Installation und verwende für den Einstieg die empfohlenen Standardeinstellungen.
3. Für die übliche MSVC-Toolchain werden Microsoft-C++-Buildtools und das Windows SDK benötigt. Falls die Einrichtung nicht automatisch erfolgt, installiere die Visual Studio Build Tools mit der Workload Desktopentwicklung mit C++.
4. Öffne anschließend ein neues PowerShell-Fenster.

Prüfe die Installation:

rustc --version
cargo --version
rustup --version

Die genauen Versionsnummern können anders aussehen als in einem Video oder Screenshot. Wichtig ist, dass alle drei Befehle funktionieren.

5. Rust unter Linux installieren (Ubuntu, Debian, Zorin OS)

Öffne ein Terminal. Installiere zunächst die grundlegenden Entwicklungswerkzeuge:

sudo apt update
sudo apt install build-essential curl pkg-config

Nutze anschließend den offiziellen rustup-Installer:

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

Dieser Befehl lädt ein Skript und führt es aus. Wenn du das Skript vorher prüfen möchtest, lade es separat herunter und lies den Inhalt. Verwende die empfohlenen Optionen. Öffne danach ein neues Terminal oder lade die Umgebung mit:

. "$HOME/.cargo/env"

Test:

rustc --version
cargo --version

6. Visual Studio Code installieren

Lade VS Code von https://code.visualstudio.com/download herunter. Unter Windows steht ein Installer bereit, für Ubuntu und Zorin OS zum Beispiel ein DEB-Paket. Installiere das Programm und starte es.

Beim ersten Öffnen kann die Oberfläche umfangreich wirken. Wir brauchen zunächst aber nur wenige Bereiche.

7. Die Oberfläche von VS Code kennenlernen

7.1 Explorer: Dateien und Ordner

Im Explorer auf der linken Seite siehst du die Dateien des aktuell geöffneten Projekts. Ein Klick auf eine Datei öffnet sie im Editor. Du kannst dort neue Dateien und Ordner anlegen.

7.2 Editor: Hier wird programmiert

In der Mitte bearbeitest du die Dateien. Rust-Code wird farbig hervorgehoben; mit der passenden Erweiterung erscheinen auch Hinweise zu Funktionen, Variablen und Fehlern.

7.3 Aktivitätsleiste: Wichtige Werkzeuge

Die Symbole am Rand öffnen beispielsweise den Explorer, die Suche, Quellcodeverwaltung, Ausführen und Debuggen und Erweiterungen.

7.4 Terminal: Befehle direkt in VS Code ausführen

Öffne Terminal → Neues Terminal. Hier geben wir später cargo-Befehle ein. Unter Windows wird häufig PowerShell verwendet, unter Linux beispielsweise Bash.

7.5 Befehlspalette: Funktionen schnell finden

Mit Strg + Umschalt + P öffnest du die Befehlspalette. Gib dort beispielsweise Format Document ein, um den Code formatieren zu lassen.

8. VS-Code-Erweiterungen für Rust installieren

Öffne links die Erweiterungsansicht oder drücke Strg + Umschalt + X. Gib den Namen der Erweiterung ins Suchfeld ein, prüfe den Herausgeber und klicke auf Installieren.

Für die ersten Lektionen genügen die ersten vier Erweiterungen. Installiere nicht zusätzlich die alte, nicht mehr gepflegte Erweiterung rust-lang.rust.

9. Das erste Rust-Projekt mit Cargo erstellen

Öffne ein Terminal und wechsle in den Ordner, in dem du neue Projekte speichern möchtest. Erstelle dann ein Projekt:

cargo new hallo_rust
cd hallo_rust

Öffne den Ordner anschließend in VS Code:

code .

Der Punkt bedeutet: aktuellen Ordner öffnen. Falls code im Terminal nicht gefunden wird, verwende Datei → Ordner öffnen und wähle hallo_rust.

Ein neues Cargo-Projekt enthält typischerweise:

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

Cargo kann zudem einen .git/-Ordner anlegen, wenn Git verfügbar und entsprechend konfiguriert ist. Nach dem ersten Build erscheint üblicherweise der Ordner target/.

• Cargo.toml: Projektname, Version und Abhängigkeiten
• src/main.rs: Startpunkt des Programms
• target/: generierte Build-Dateien

10. Dein erstes Rust-Programm

Öffne src/main.rs und ersetze den Inhalt durch:

fn main() {
    println!("Hallo von der Know-How-Schmiede!");
    println!("Mein erstes Rust-Programm funktioniert.");
}

Speichere mit Strg + S.

Was bedeutet der Code?

• fn leitet eine Funktion ein.
• main() ist der Einstiegspunkt des Programms.
• { ... } umfasst den Funktionskörper.
• println! gibt Text auf der Konsole aus und fügt einen Zeilenumbruch an.
• ; schließt hier eine Anweisung ab.

11. Programm ausführen

Im integrierten Terminal (innerhalb des Projektordners) gibst du ein:

cargo run

Cargo liest die Projektdateien, übersetzt den Code und startet das Programm. Du solltest unter anderem sehen:

Hallo von der Know-How-Schmiede!
Mein erstes Rust-Programm funktioniert.

12. Wichtige Cargo-Befehle

Die letzten beiden Prüfwerkzeuge können bei Bedarf installiert werden:

rustup component add rustfmt clippy

13. Fehler erkennen und verstehen

Probiere diesen Code aus:

fn main() {
    let zahl = 10;
    zahl = 20;
    println!("{}", zahl);
}

Der Compiler meldet einen Fehler: zahl darf nicht verändert werden. Rust-Variablen sind standardmäßig unveränderlich.

So funktioniert es:

fn main() {
    let mut zahl = 10;
    zahl = 20;
    println!("{}", zahl);
}

Das Schlüsselwort mut erlaubt die Änderung. Achte bei Fehlermeldungen auf den Dateinamen, die Zeilennummer, die Beschreibung und mögliche Vorschläge des Compilers.

14. Code formatieren und Einstellungen anpassen

Im Projektordner kannst du deinen Quellcode mit folgendem Befehl formatieren:

cargo fmt

Aktiviere in VS Code bei Bedarf die Option Format On Save. Für Rust eignet sich diese Konfiguration in der Benutzer- oder Workspace-settings.json:

{
  "[rust]": {
    "editor.defaultFormatter": "rust-lang.rust-analyzer",
    "editor.formatOnSave": true
  },
  "rust-analyzer.check.command": "clippy",
  "rust-analyzer.cargo.allTargets": true,
  "editor.inlayHints.enabled": "on"
}

Die Einstellung clippy setzt voraus, dass die entsprechende Komponente installiert ist.

15. Debugging: Den Programmablauf untersuchen

Ein Debugger hält ein Programm an bestimmten Stellen an, damit du Variablen und den Ablauf kontrollieren kannst.

fn main() {
    let breite = 10.0;
    let hoehe = 5.0;
    let flaeche = breite * hoehe;
    println!("Fläche: {}", flaeche);
}

Setze durch einen Klick links neben der Zeilennummer einen Breakpoint bei der Flächenberechnung. Mit einer passend eingerichteten CodeLLDB-Konfiguration kannst du im Debugmodus starten und dir breite, hoehe und flaeche anzeigen lassen.

Hinweis: Der Debugger benötigt je nach Betriebssystem eine passende Konfiguration. Ein cargo run funktioniert unabhängig davon.

16. Nützliche Tastenkombinationen

Die tatsächlichen Tastenkombinationen können je nach Plattform und Tastaturbelegung abweichen.

17. Typische Anfängerprobleme

cargo wird nicht gefunden. Schließe das Terminal und öffne es nach der Rust-Installation erneut. Teste cargo --version.

rust-analyzer zeigt keine Hinweise. Stelle sicher, dass die Erweiterung aktiviert ist und der vollständige Projektordner mit Cargo.toml in VS Code geöffnet wurde.

cargo run funktioniert nicht. Prüfe, ob du dich im richtigen Ordner befindest: Die Datei Cargo.toml muss dort liegen.

Unter Windows erscheint ein Linkerfehler. Kontrolliere die Microsoft-C++-Buildtools und das Windows SDK.

Der Compiler meldet einen Fehler. Lies die Meldung vollständig, einschließlich Zeilennummer und Verbesserungsvorschlag. Viele Probleme entstehen durch kleine Tippfehler oder nicht passende Datentypen.

18. Übungsaufgabe: Ein Flächenrechner

Erstelle mit Cargo ein neues Projekt namens flaechenrechner. Dein Programm soll die Länge 120 mm und Breite 80 mm eines Rechtecks in Variablen speichern und die Fläche berechnen.

Erwartete Ausgabe:

Rechteck-Rechner
Länge: 120 mm
Breite: 80 mm
Fläche: 9600 mm²

Versuche die Aufgabe zunächst ohne Hilfe zu lösen.

fn main() {
    let laenge = 120.0;
    let breite = 80.0;
    let flaeche = laenge * breite;

    println!("Rechteck-Rechner");
    println!("Länge: {} mm", laenge);
    println!("Breite: {} mm", breite);
    println!("Fläche: {} mm²", flaeche);
}

19. Wie geht es weiter?

Jetzt kennst du die Entwicklungsumgebung und kannst eigene Rust-Projekte anlegen, starten und bearbeiten. Im anschließenden Rust-Grundlagenkurs lernst du Variablen, Datentypen, Bedingungen, Schleifen, Funktionen und später das Ownership-System kennen. Darauf aufbauend kannst du Desktop-Anwendungen entwickeln oder den Raspberry Pi Pico mit Rust programmieren.

20. Weiterführende Links

• Offizielle Rust-Website
• Rust installieren
• Das Rust-Buch
• Cargo-Handbuch
• Visual Studio Code
• Rust in Visual Studio Code
• rust-analyzer

Fazit: Mit Rust, Cargo und Visual Studio Code hast du eine kostenlose Entwicklungsumgebung, in der du vom ersten Konsolenprogramm bis zur komplexen Anwendung arbeiten kannst. Der beste Einstieg ist, kleine Programme selbst zu schreiben, zu verändern und bewusst Fehler zu untersuchen.

Alle drei Rust-Kurse entdecken