Rust: Programmiersprache für sichere und schnelle Software

Ownership, Borrowing, Cargo und typische Einsatzfelder: ein verständlicher Einstieg in Rust für Entwicklerteams und Entscheider
Aktualisiert:
Abstract
- #Rust
- #Programmiersprache
- #Speichersicherheit
- #Ownership
- #Cargo
- #Systemprogrammierung
- #Programmierung
- #Entwicklung
- #Software
Wie Rust Speicherfehler verhindert, ohne auf Tempo zu verzichten, und wann sich der Umstieg lohnt
Ein Programm liest eine Kundenliste ein, gibt den Speicher frei und greift wenige Zeilen später noch einmal darauf zu. In C oder C++ kompiliert dieser Code ohne Murren. Im besten Fall stürzt die Anwendung ab, im schlechtesten liest sie fremde Daten oder öffnet einem Angreifer die Tür. Fehler dieser Art, im Fachjargon Use-after-free oder Pufferüberlauf, stehen seit Jahrzehnten hinter einem großen Teil der schweren Sicherheitslücken in Browsern und Betriebssystemen.
Rust setzt genau hier an. Die Sprache erzeugt Maschinencode, der ähnlich schnell läuft wie C++, lehnt aber Programme mit solchen Speicherfehlern schon beim Kompilieren ab. Das gelingt ohne Garbage Collector, also ohne einen Hintergrunddienst, der zur Laufzeit ungenutzten Speicher einsammelt. Der Preis dafür ist eine Lernkurve, die viele Einsteiger unterschätzen. Dieser Überblick erklärt die Grundideen, die Werkzeuge und die Einsatzfelder, damit Sie einschätzen können, ob Rust zu Ihrem Projekt passt.
Was Rust von C++, Java und Python unterscheidet
Programmiersprachen verwalten Speicher traditionell auf eine von zwei Arten. In C und C++ fordert der Code Speicher an und gibt ihn selbst wieder frei. Das ist schnell und berechenbar, aber fehleranfällig: Wer das Freigeben vergisst, erzeugt Speicherlecks, wer zu früh freigibt, greift ins Leere. Java, C#, Go oder Python nehmen Entwicklerinnen und Entwicklern diese Arbeit über einen Garbage Collector ab. Das ist bequem und sicher, kostet aber Rechenzeit und führt zu kurzen, schwer vorhersagbaren Pausen.
Rust wählt einen dritten Weg. Der Compiler prüft anhand fester Regeln, wem ein Wert gehört und wie lange er gültig ist, und fügt die Freigabe an der richtigen Stelle selbst ein. Zur Laufzeit gibt es keinen Aufräumdienst, und trotzdem kann der Code nicht auf bereits freigegebenen Speicher zugreifen. Diese Regeln heißen Ownership und Borrowing. Sie sind der Kern der Sprache und der Grund, warum der Einstieg anfangs Geduld verlangt.
Wie die Sprache aus einem Nebenprojekt bei Mozilla entstand und den Weg bis in den Linux-Kernel fand, beschreibt unser Beitrag zum Aufstieg von Rust. Hier geht es um die Frage, wie Rust im Alltag funktioniert.
Ownership: Jeder Wert hat genau einen Besitzer
Die erste Regel ist schnell erklärt: Jeder Wert im Speicher gehört genau einer Variablen. Verlässt diese Variable ihren Gültigkeitsbereich, etwa am Ende einer Funktion, gibt Rust den Speicher automatisch frei. Weist der Code den Wert einer anderen Variablen zu, wandert der Besitz mit. Die alte Variable ist danach nicht mehr verwendbar.
fn main() {
let bestellung = String::from("Bestellung 4711");
let archiv = bestellung; // Der Besitz wandert zu `archiv`
// println!("{bestellung}"); // Würde nicht kompilieren: Wert wurde verschoben
println!("{archiv}");
} // Hier gibt Rust den Speicher von `archiv` frei
Angenommen, ein Entwickler entfernt das Kommentarzeichen in der auskommentierten Zeile. Der Compiler bricht dann mit einer Fehlermeldung ab, die genau benennt, in welcher Zeile der Wert verschoben wurde. Was in C++ erst im Betrieb als Absturz auffallen würde, scheitert in Rust vor dem ersten Test. Einfache Werte wie Zahlen oder Wahrheitswerte kopiert Rust übrigens einfach, für sie gilt diese Einschränkung nicht.
Borrowing und Borrow Checker: Ausleihen nach festen Regeln
Würde jeder Funktionsaufruf den Besitz übernehmen, wäre Rust kaum benutzbar. Deshalb können Werte ausgeliehen werden, technisch über Referenzen. Dabei gilt eine einfache, aber strenge Regel: Entweder beliebig viele Stellen lesen gleichzeitig, oder genau eine Stelle darf schreiben. Beides zugleich ist verboten.
fn zeichen_zaehlen(text: &str) -> usize {
text.chars().count()
}
fn vermerk_anhaengen(text: &mut String, vermerk: &str) {
text.push_str(vermerk);
}
fn main() {
let mut notiz = String::from("Angebot Müller GmbH");
let laenge = zeichen_zaehlen(¬iz); // lesende Leihe mit &
vermerk_anhaengen(&mut notiz, " (geprüft)"); // schreibende Leihe mit &mut
println!("{notiz}, vorher {laenge} Zeichen");
}
Der Teil des Compilers, der diese Regeln durchsetzt, heißt Borrow Checker. Er stellt außerdem sicher, dass keine Referenz länger lebt als der Wert, auf den sie zeigt. Die Gültigkeitsdauer einer Referenz nennt Rust Lifetime. In den meisten Fällen leitet der Compiler sie selbst ab, nur in kniffligen Fällen muss man sie ausdrücklich angeben.
Die Regel „viele Leser oder ein Schreiber“ hat einen Nebeneffekt, der in der Praxis oft wichtiger ist als die Speichersicherheit: Sie verhindert Data Races, also Fehler, bei denen zwei Threads gleichzeitig dieselben Daten verändern. Solche Fehler treten in anderen Sprachen nur sporadisch auf und sind entsprechend schwer zu finden. Rust weist sie beim Kompilieren zurück. Wer tiefer einsteigen will, findet in der Infothek eine ausführliche Erklärung zu Ownership, Borrowing und Lifetimes.
Was unsafe bedeutet
Für hardwarenahe Arbeit, etwa den Zugriff auf Gerätespeicher oder den Aufruf von C-Bibliotheken, kennt Rust das Schlüsselwort unsafe. Darin darf der Code Dinge tun, die der Compiler nicht prüfen kann. Das Prinzip dahinter: Unsichere Stellen sind klein, ausdrücklich markiert und bei einem Code-Review leicht zu finden. Der übrige Code bleibt abgesichert. Speichersicherheit ist in Rust also keine absolute Garantie, sondern der Normalfall, von dem man nur bewusst abweicht.
Fehler als Werte: Result und Option statt Null und Exceptions
Neben dem Speichermodell prägt ein zweites Konzept den Rust-Alltag. Rust kennt weder den Wert null noch Exceptions im Stil von Java. Eine Funktion, die scheitern kann, gibt stattdessen einen Result-Wert zurück, der entweder das Ergebnis oder einen Fehler enthält. Ein Wert, der fehlen kann, steckt in einem Option. Der Compiler zwingt dazu, beide Fälle zu behandeln.
use std::fs;
use std::io;
fn konfiguration_lesen(pfad: &str) -> Result<String, io::Error> {
let inhalt = fs::read_to_string(pfad)?; // Fehler wird an den Aufrufer weitergereicht
Ok(inhalt.trim().to_string())
}
fn main() {
match konfiguration_lesen("einstellungen.toml") {
Ok(text) => println!("Konfiguration geladen: {text}"),
Err(fehler) => eprintln!("Konfiguration nicht lesbar: {fehler}"),
}
}
Das Fragezeichen hinter dem Dateizugriff reicht einen Fehler direkt an den Aufrufer weiter, ohne dass der Code unübersichtlich wird. Für ein Team bedeutet das: Die Frage „Was passiert, wenn die Datei fehlt?“ lässt sich nicht vergessen. Das macht Rust-Programme anfangs etwas länger, im Betrieb aber deutlich berechenbarer.
Cargo und Crates: die Werkzeugkette
Ein Grund, warum Entwicklerinnen und Entwickler Rust trotz der Lernkurve schätzen, sind die Werkzeuge. Installiert wird Rust in der Regel über rustup, das Compiler und Werkzeuge verwaltet und aktuell hält. Im Zentrum steht Cargo, das Build-System und der Paketmanager in einem.
cargo new rechnungs_tool # legt Projekt mit Cargo.toml und src/main.rs an
cd rechnungs_tool
cargo add serde --features derive # Abhängigkeit hinzufügen
cargo run # kompilieren und starten
cargo test # Tests ausführen
Die Projektbeschreibung steht in der Datei Cargo.toml. Dort legen Sie Name, Version, Abhängigkeiten und die Edition fest, also den Sprachstand, nach dem der Code übersetzt wird:
[package]
name = "rechnungs_tool"
version = "0.1.0"
edition = "2024"
[dependencies]
serde = { version = "1", features = ["derive"] }
Bibliotheken heißen in Rust Crates. Sie werden über das zentrale Verzeichnis crates.io bezogen. Dazu kommen Werkzeuge, die bei anderen Sprachen erst zusammengesucht werden müssen: rustfmt formatiert den Code einheitlich, clippy weist auf typische Fehler und umständliche Konstrukte hin, und der Sprachserver rust-analyzer liefert Autovervollständigung in gängigen Editoren. Für Teams heißt das: Es gibt kaum Diskussionen über Formatierung oder Build-Skripte, weil der Standard mitgeliefert wird.
Ein Wort der Vorsicht gehört dazu. Wie bei npm oder PyPI holen schon kleine Projekte schnell Dutzende Crates ins Haus. Jede davon ist Code von Dritten, der gepflegt und auf Sicherheitslücken geprüft werden muss. Werkzeuge wie cargo audit gleichen die Abhängigkeiten mit einer Datenbank bekannter Schwachstellen ab.
Versionen und Editionen: wie Rust stabil bleibt
Rust erscheint im Sechswochenrhythmus in einer neuen stabilen Version. Das klingt nach Unruhe, ist aber gut beherrschbar, weil das Projekt Rückwärtskompatibilität zusagt: Code, der mit einer älteren 1.x-Version kompiliert, soll auch mit neueren Versionen kompilieren.
Größere Änderungen an der Sprache bündelt Rust in Editionen. Bisher gibt es die Editionen 2015, 2018, 2021 und 2024. Die aktuelle Edition 2024 kam im Februar 2025 mit Rust 1.85. Jedes Projekt wählt seine Edition selbst, und Crates verschiedener Editionen lassen sich problemlos kombinieren. Ein Team muss also nicht alles gleichzeitig umstellen. Der Befehl cargo fix --edition übernimmt einen großen Teil der Migration automatisch.
Für Unternehmen ist dieses Modell ein Pluspunkt: Die Sprache entwickelt sich weiter, ohne dass bestehender Code regelmäßig angepasst werden muss.
Wo Rust heute eingesetzt wird
Rust hat den Ruf, eine Sprache für Betriebssysteme zu sein. Das stimmt, greift aber zu kurz.
- Systemsoftware und Sicherheit: Seit Linux 6.1 Ende 2022 können Teile des Kernels in Rust geschrieben werden, vor allem Treiber. Auch Google setzt Rust in Android ein, Microsoft in Teilen von Windows. Gemeinsam ist diesen Projekten das Ziel, die Zahl der Speicherfehler in sicherheitskritischem Code zu senken.
- Backends und Web-APIs: Frameworks wie Axum oder Actix Web eignen sich für Dienste mit hoher Last und geringem Speicherbedarf. Im Cloud-Betrieb, wo nach Ressourcen abgerechnet wird, spart das bares Geld. Mehr dazu lesen Sie in unserem Infothek-Artikel zu Web-APIs mit Rust.
- Kommandozeilenwerkzeuge: Viele moderne Entwicklerwerkzeuge sind in Rust geschrieben, etwa das Suchprogramm ripgrep oder die Python-Werkzeuge Ruff und uv. Sie starten schnell und lassen sich als einzelne Datei ohne Laufzeitumgebung ausliefern.
- WebAssembly: Rust lässt sich in WebAssembly übersetzen, ein Binärformat, das Browser nahezu mit nativer Geschwindigkeit ausführen. Das lohnt sich für rechenintensive Teile von Webanwendungen, etwa Bildbearbeitung oder Simulationen.
- Embedded-Systeme: Auf Mikrocontrollern ohne Betriebssystem kann Rust ohne Standardbibliothek laufen. Für sicherheitskritische Branchen wie Automotive gibt es inzwischen qualifizierte Compiler-Varianten, etwa Ferrocene.
- Desktop-Anwendungen: Mit Tauri entstehen schlanke Desktop-Programme, deren Oberfläche aus Webtechnik besteht und deren Logik in Rust läuft. Unser Beitrag zu Tauri und Rust zeigt, wie das funktioniert.
Dazu kommt ein regulatorischer Rückenwind. US-Behörden wie die CISA empfehlen seit 2023 ausdrücklich den Umstieg auf speichersichere Sprachen, und auch in Europa wächst mit dem Cyber Resilience Act der Druck, Sicherheit schon bei der Entwicklung nachzuweisen. Rust ist dabei nicht die einzige Antwort, aber eine der wenigen verbreiteten speichersicheren Sprachen ohne Garbage Collector.
Wo Rust mühsam ist
Bei aller Begeisterung in der Entwicklergemeinde hat Rust handfeste Nachteile, die in eine ehrliche Bewertung gehören.
Die Lernkurve ist real. Wer aus Python oder JavaScript kommt, kämpft in den ersten Wochen mit dem Borrow Checker. Typische Datenstrukturen wie verkettete Listen oder Graphen mit gegenseitigen Verweisen lassen sich nicht so schreiben wie in anderen Sprachen. Erfahrungsgemäß dauert es einige Monate, bis ein Team produktiv und idiomatisch arbeitet.
Die Kompilierzeiten sind lang. Der Compiler prüft viel und optimiert gründlich. Bei großen Projekten kann ein vollständiger Build deutlich länger dauern als bei Go oder Java. Inkrementelle Builds und gute Projektaufteilung mildern das.
Das Ökosystem ist in manchen Bereichen jung. Für Web-Backends, Kommandozeilen und Netzwerkdienste gibt es ausgereifte Crates. Bei grafischen Oberflächen, Data Science oder Unternehmensintegration ist die Auswahl kleiner als bei Java, C# oder Python.
Fachkräfte sind knapp. Rust-Erfahrung ist gefragter als verfügbar. Wer ein Projekt in Rust beginnt, sollte einplanen, das eigene Team weiterzubilden.
Eine neue Entwicklung verschiebt diese Rechnung: KI-Assistenten senken die Einstiegshürde spürbar, weil sie Compilerfehler erklären und idiomatischen Code vorschlagen. Warum das ausgerechnet Rust zugutekommt, beleuchtet unser Beitrag Programmiersprachen 2026: Wenn die KI Rust besser schreibt.
Was das für Ihr Team bedeutet
Rust ist keine Sprache für jedes Projekt. Für ein klassisches Geschäftsformular oder eine schnelle Datenanalyse sind Java, C#, TypeScript oder Python meist die pragmatischere Wahl. Ihre Stärken spielt die Sprache dort aus, wo Leistung, Ressourcenverbrauch und Sicherheit zugleich zählen: bei Netzwerkdiensten, Werkzeugen, Embedded-Software und Komponenten, die nicht abstürzen dürfen.
Unsere Empfehlung: Beginnen Sie nicht mit dem Kernsystem, sondern mit einem abgegrenzten Baustein. Angenommen, ein Logistikunternehmen hat einen Importdienst, der nachts große CSV-Dateien verarbeitet und regelmäßig an Speichergrenzen stößt. Ein solcher Dienst lässt sich in Rust neu schreiben, über eine klare Schnittstelle anbinden und im Betrieb vergleichen. So sammelt das Team Erfahrung, ohne das ganze Projekt auf eine neue Sprache zu setzen. Wichtig ist, die Einarbeitung ehrlich einzuplanen, statt sie nebenbei zu erwarten.
Wenn Sie den Einstieg strukturiert angehen oder ein bestehendes C- oder C++-Projekt schrittweise absichern möchten, finden Sie auf unserer Seite zur Softwareentwicklung mit Rust Beratung, Coaching und Seminare.
Häufige Fragen zu Rust
Ist Rust schwer zu lernen?
Schwerer als Python oder Go, ja. Die Syntax selbst ist nicht das Problem, sondern das Denken in Besitz und Ausleihen. Hilfreich ist, dass die Fehlermeldungen des Compilers ungewöhnlich ausführlich sind und oft direkt eine Lösung vorschlagen. Das offizielle Buch „The Rust Programming Language“ ist kostenlos online verfügbar und gilt als guter Einstieg.
Ist Rust schneller als C++?
In der Regel spielen beide in derselben Liga. Je nach Aufgabe liegt mal die eine, mal die andere Sprache vorn, meist entscheidet eher die Qualität des Codes als die Sprache. Der Unterschied liegt in der Sicherheit: Rust schließt ganze Fehlerklassen beim Kompilieren aus, die in C++ erst Tests, Code-Reviews oder Analysewerkzeuge finden müssen.
Lässt sich Rust mit bestehendem C- oder C++-Code kombinieren?
Ja. Rust kann C-Funktionen aufrufen und selbst Funktionen mit C-Schnittstelle bereitstellen. Werkzeuge wie bindgen erzeugen die nötigen Verbindungsstücke automatisch. Viele Unternehmen nutzen genau diesen Weg, um einzelne Module schrittweise zu ersetzen, statt alles neu zu schreiben.
Kann man mit Rust grafische Oberflächen entwickeln?
Ja, aber das Ökosystem ist weniger einheitlich als bei anderen Sprachen. Verbreitet sind Tauri für Anwendungen mit Weboberfläche sowie native Bibliotheken wie iced, egui oder Slint. Für komplexe Geschäftsanwendungen mit vielen Formularen ist der Aufwand derzeit oft höher als mit etablierten Frameworks.
Kategorien
Schlagworte