Rust vs. C++, Go und Python

„Soll ich Rust lernen, oder Go, oder lieber bei Python bleiben?“ Das ist eine der häufigsten Fragen, wenn man Rust entdeckt. Die ehrliche Antwort: Es kommt darauf an, was du bauen willst. Jede Sprache auf dieser Seite ist eine gute Sprache, die Millionen Menschen nutzen. Jede hat einfach andere Kompromisse gewählt.

Stell dir Programmiersprachen wie Fahrzeuge vor. Ein Sportwagen, ein Lieferwagen und ein Fahrrad sind alle „gut“. Nur würdest du mit dem Fahrrad keinen Umzug machen. Diese Seite erklärt die Kompromisse in einfachen Worten, damit du das passende Werkzeug für deine Aufgabe findest. Wir bemühen uns, fair zu bleiben – auch bei den Schwächen von Rust.

Was Rust gut kann

Das zentrale Versprechen von Rust lautet: Geschwindigkeit und Sicherheit gleichzeitig.

• Schnell wie C und C++. Rust kompiliert zu nativem Maschinencode und hat keinen Garbage Collector (automatische Speicherbereinigung). Es gibt also keine Pausen, in denen Speicher aufgeräumt wird.
• Speichersicher ohne Garbage Collector. Die Regeln für Ownership (Eigentum) und Borrowing (Ausleihen) prüft der Compiler beim Kompilieren. Ganze Gruppen von Fehlern (Zugriff auf freigegebenen Speicher, Data Races zwischen Threads) werden abgelehnt, bevor das Programm überhaupt läuft.
• Hervorragende Werkzeuge von Haus aus. Ein einziges Tool, Cargo, baut deinen Code, lädt Bibliotheken herunter, führt Tests aus und erzeugt Dokumentation. Der Formatierer (rustfmt) und der Linter (clippy) sind offiziell.
• Hilfreiche Fehlermeldungen. Der Compiler sagt dir oft genau, wie du das Problem behebst.

Und offenbar macht Rust auch Spaß: In der Stack Overflow Developer Survey 2025 (auf Englisch) war Rust erneut die „most admired“, also die am meisten bewunderte Programmiersprache. Das heißt: Die meisten, die Rust nutzen, wollen auch dabei bleiben.

Dieselbe Aufgabe in vier Sprachen

Fangen wir klein an: Wir addieren die geraden Zahlen in einer Liste. So sieht das in Rust aus:

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let sum: i32 = numbers.iter().filter(|n| *n % 2 == 0).sum();
    println!("Summe der geraden Zahlen: {sum}");
}

Ausgabe:

Summe der geraden Zahlen: 12

▶ Selbst ausprobieren

Dasselbe Programm in C++:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
    int sum = 0;
    for (int n : numbers) {
        if (n % 2 == 0) {
            sum += n;
        }
    }
    std::cout << "Summe der geraden Zahlen: " << sum << "\n";
}

In Go:

package main

import "fmt"

func main() {
  numbers := []int{1, 2, 3, 4, 5, 6}
  sum := 0
  for _, n := range numbers {
    if n%2 == 0 {
      sum += n
    }
  }
  fmt.Println("Summe der geraden Zahlen:", sum)
}

Und in Python:

numbers = [1, 2, 3, 4, 5, 6]
total = sum(n for n in numbers if n % 2 == 0)
print("Summe der geraden Zahlen:", total)

Alle vier geben dieselbe Zeile aus. Python ist am kürzesten, Go und C++ nutzen eine einfache Schleife, und Rust verwendet eine Kette aus einem Iterator und einem Closure (du könntest in Rust aber auch eine for-Schleife schreiben). Bei so kleinen Programmen geht es vor allem um Stil. Die echten Unterschiede zeigen sich erst in größeren Programmen.

Rust vs. C++

C++ und Rust zielen auf denselben Bereich: schnelle Programme mit voller Kontrolle über den Speicher, etwa Browser, Game-Engines, Datenbanken und Betriebssysteme. Der große Unterschied ist, wer prüft, ob der Speicher richtig verwendet wird.

In C++ bist das du. Hier ein klassischer Fehler. Ein C++-Compiler akzeptiert diesen Code ohne Murren. Aber push_back kann den Vektor an eine neue Stelle im Speicher verschieben. Dann zeigt first womöglich auf Speicher, der schon freigegeben wurde:

std::vector<int> v = {1, 2, 3};
int& first = v[0];
v.push_back(4);              // kann den Speicher des Vektors verschieben ...
std::cout << first << "\n";  // ... dann liest das hier freigegebenen Speicher

Derselbe Fehler lässt sich in Rust gar nicht kompilieren:

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    v.push(4);
    println!("{first}");
}

error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let first = &v[0];
  |                  - immutable borrow occurs here
4 |     v.push(4);
  |     ^^^^^^^^^ mutable borrow occurs here
5 |     println!("{first}");
  |                ----- immutable borrow later used here

Die Meldung bedeutet: v kann nicht veränderbar ausgeliehen werden, weil es bereits unveränderbar ausgeliehen ist – und diese Ausleihe (first) wird später noch benutzt.

In der Praxis ist das sehr wichtig. Das Chromium-Team berichtet, dass rund 70 % seiner schweren Sicherheitslücken Probleme mit der Speichersicherheit sind (auf Englisch). Das Android-Team von Google schreibt seit einigen Jahren neuen Code in Rust. 2022 meldete es null gefundene Speichersicherheitslücken im Rust-Code von Android (auf Englisch), und 2025 eine mehr als 1000-mal geringere Dichte an Speichersicherheitslücken als im C- und C++-Code (auf Englisch). Auch der Linux-Kernel (auf Englisch) unterstützt inzwischen Code in Rust.

Werkzeuge: C++ hat viele Build-Systeme und Paketmanager, und Teams verbringen oft viel Zeit mit dem Einrichten. Rust hat mit Cargo ein Standardwerkzeug. Dadurch wird jedes Rust-Projekt auf dieselbe Weise gebaut.

Lernkurve: Beide sind schwer. C++ ist riesig, und viele seiner Regeln lernt man erst durch Fehler zur Laufzeit. Die Regeln von Rust sind streng, aber der Compiler setzt sie durch und erklärt sie. Du lernst sie also schon beim Kompilieren.

Wo C++ weiterhin vorne liegt: Jahrzehnte an bestehendem Code, Bibliotheken und erfahrenen Entwicklern. Wenn deine Firma oder deine Game-Engine auf C++ aufbaut, ist C++ oft die praktische Wahl. Rust kann C-Code aufrufen, und C++ über Schnittstellen im C-Stil. Beides zu mischen kostet aber Aufwand.

Rust vs. Go

Go und Rust werden oft verglichen. Beide sind modern, kompiliert und beliebt für Server und Kommandozeilen-Tools. Sie wurden aber mit unterschiedlichen Zielen entworfen.

Garbage Collection vs. Ownership. Go nutzt einen Garbage Collector (auf Englisch), der ungenutzten Speicher findet und freigibt, während dein Programm läuft. Dadurch ist Go-Code einfacher zu schreiben: Du musst nie überlegen, wem ein Wert gehört. Der Preis dafür sind etwas mehr Speicher- und CPU-Verbrauch und kurze Pausen. Rust hat keinen Garbage Collector. Speicher wird an einer bekannten Stelle freigegeben, nämlich wenn der Owner seinen Gültigkeitsbereich (Scope) verlässt. Das sorgt für besser vorhersagbare Performance, aber du musst Ownership und Borrowing lernen.

Nebenläufigkeit. Die Goroutines und Channels von Go sind berühmt dafür, wie einfach sie sind. Hier ein kleines Beispiel, das drei Zahlen parallel quadriert und addiert:

results := make(chan int)

for n := 1; n <= 3; n++ {
  go func() {
    results <- n * n
  }()
}

total := 0
for i := 0; i < 3; i++ {
  total += <-results
}
fmt.Println("Summe:", total)

Die Rust-Version nutzt Threads und einen Channel. Sie ist etwas ausführlicher: Du klonst den Sender für jeden Thread und verwendest move:

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    for n in 1..=3 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(n * n).unwrap();
        });
    }
    drop(tx); // unsere Kopie schließen, damit die Schleife unten enden kann

    let total: i32 = rx.iter().sum();
    println!("Summe: {total}");
}

Ausgabe:

Summe: 14

▶ Selbst ausprobieren

Was du für die zusätzliche Tipparbeit bekommst: Rust weigert sich, Code zu kompilieren, in dem zwei Threads gleichzeitig dieselben Daten ändern könnten (ein Data Race). In Go sind Data Races möglich. Go bietet dafür einen Race Detector (auf Englisch), der sie findet, während das Programm läuft. Mehr dazu findest du unter Nebenläufigkeit.

Kompilierzeiten. Go wurde für schnelles Kompilieren gebaut. In der FAQ heißt es, ein großes Programm sollte sich in höchstens ein paar Sekunden bauen lassen (auf Englisch). Rust kompiliert langsamer, weil der Compiler viel mehr prüft und optimiert. Bei großen Projekten merkst du das.

Einfachheit. Go ist bewusst eine kleine Sprache mit wenigen Features. Viele finden deshalb, dass sie Go-Code schnell lesen können. Rust hat mehr Features (Traits, Generics, Lifetimes, Makros). Die geben dir mehr Möglichkeiten, brauchen aber länger zum Lernen.

Rust vs. Python

Python und Rust sind sehr verschieden. Oft werden sie zusammen eingesetzt, statt sich gegenseitig zu ersetzen.

Geschwindigkeit. Python wird interpretiert. Reiner Python-Code, der viel rechnet, ist deshalb deutlich langsamer als kompilierter Code. Darum erledigen beliebte Python-Bibliotheken die schwere Arbeit oft unter der Haube in C, C++ oder Rust.

Typen. In Python werden Typen erst geprüft, während das Programm läuft. Diese Funktion klappt mit einer Zahl und scheitert mit einer Zeichenkette. Das merkst du aber erst, wenn die Zeile ausgeführt wird:

def add_tax(price):
    return price * 1.2

print(add_tax(10))    # 12.0
print(add_tax("10"))  # TypeError: can't multiply sequence by non-int of type 'float'

Python kennt optionale Type Hints, aber die Python-Laufzeit setzt sie nicht durch (auf Englisch). In Rust wird jeder Typ geprüft, bevor das Programm läuft:

fn add_tax(price: f64) -> f64 {
    price * 1.2
}

fn main() {
    println!("{}", add_tax(10.0));
    println!("{}", add_tax("10"));
}

error[E0308]: mismatched types
 --> src/main.rs:7:28
  |
7 |     println!("{}", add_tax("10"));
  |                    ------- ^^^^ expected `f64`, found `&str`
  |                    |
  |                    arguments to this function are incorrect

Der Compiler meldet „mismatched types“: Die Funktion erwartet ein f64, bekommt aber ein &str.

Wann Python das bessere Werkzeug bleibt: schnelle Skripte, Datenanalyse, Machine Learning, Notebooks, Automatisierung und der Einstieg ins Programmieren. Das Python-Ökosystem für Data Science ist riesig, und du kannst eine Idee in wenigen Minuten ausprobieren. Wenn dein Programm die meiste Zeit auf das Netzwerk oder eine Datenbank wartet, spielt die Geschwindigkeit von Python oft keine Rolle.

Beides kombinieren: Mit dem Projekt PyO3 (auf Englisch) schreibst du Python-Module in Rust. So behältst du deinen Python-Code und verlagerst nur den langsamen Teil nach Rust. Einige beliebte Python-Tools sind selbst in Rust geschrieben. Die Stack-Overflow-Umfrage erwähnt zum Beispiel, dass der Python-Paketmanager uv in Rust gebaut ist (auf Englisch).

Direkter Vergleich

Das sind allgemeine Tendenzen, keine festen Regeln. Ein gut geschriebenes Programm kann in jeder dieser Sprachen „schnell genug“ sein.

	Rust	C++	Go	Python
Geschwindigkeit	Sehr schnell, nativer Code, kein GC	Sehr schnell, nativer Code, kein GC	Schnell, nativer Code mit GC	Bei viel Rechenarbeit in reinem Python langsamer
Speichersicherheit	Beim Kompilieren geprüft (außerhalb von unsafe)	Liegt in der Verantwortung des Programmierers	GC; Data Races trotzdem möglich	GC; sicher, aber Typfehler erst zur Laufzeit
Lernkurve	Anfangs steil	Steil, und eine sehr große Sprache	Sanft	Am sanftesten
Kompilierzeit	Eher langsam	Eher langsam (je nach Projekt)	Sehr schnell	Kein Kompilierschritt
Ökosystem	Jünger, wachsend; Cargo eingebaut	Riesig und ausgereift; viele Build-Tools	Starke Standardbibliothek, ideal für Server	Enorm, vor allem für Daten und ML
Typische Einsatzgebiete	CLI-Tools, Server, Systemcode, WebAssembly, Embedded	Spiele, Browser, Hochleistungs- und Altsysteme	Webdienste, Cloud- und DevOps-Tools	Skripte, Data Science, ML, Automatisierung

Wann solltest du Rust wählen?

Stell dir diese Fragen:

• Brauchst du maximale Geschwindigkeit oder wenig Speicherverbrauch, etwa für eine Game-Engine, eine Datenbank oder Code auf einem kleinen Gerät? Dann ist Rust (oder C++) eine starke Wahl.
• Werden Fehler teuer? Sicherheitskritischer Code, lange laufende Server und Code, auf den viele Menschen angewiesen sind, profitieren am meisten von den Prüfungen beim Kompilieren.
• Baust du ein Kommandozeilen-Tool, das du weitergeben willst? Rust erzeugt eine einzelne, schnelle Binärdatei, ohne dass eine Laufzeitumgebung installiert werden muss. Go ist hier ebenfalls großartig.
• Brauchst du schnell einen Webdienst, mit einem Team, für das all diese Sprachen neu sind? Mit Go kommst du wahrscheinlich schneller ans Ziel. Rust funktioniert auch gut (siehe Projekt: Web-API), aber die Einarbeitung dauert länger.
• Geht es um ein schnelles Skript, Datenanalyse oder ein ML-Experiment? Nimm Python. Greif später über PyO3 zu Rust, falls ein Teil zu langsam wird.
• Gibt es eine große bestehende C++-Codebasis? Bleib vorerst bei C++, oder führe Rust in neuen, getrennten Teilen ein – so wie Android.

Und wenn du einfach ein besserer Programmierer werden willst: Rust bringt dir bei, wie Speicher wirklich funktioniert. Dieses Wissen hilft dir in jeder anderen Sprache.

Die ehrlichen Schwächen von Rust

Rust ist nicht perfekt. Hiermit tun sich die meisten am schwersten:

• Die Lernkurve ist real. Die ersten Wochen mit dem Borrow Checker können frustrierend sein. Rechne damit, eine Weile „gegen den Compiler zu kämpfen“. Sobald Ownership „Klick“ macht, wird es viel leichter.
• Die Kompilierzeiten sind länger als bei Go, vor allem bei großen Projekten und Release-Builds.
• Manches ist schwerer auszudrücken. Graphartige Daten mit vielen Verbindungen zwischen Objekten oder Code, der viel veränderbaren Zustand teilt, brauchen Werkzeuge wie Smart Pointer und mehr Planung.
• Das Ökosystem ist jünger. In manchen Bereichen (GUI-Apps, bestimmte wissenschaftliche Bibliotheken) gibt es weniger ausgereifte Optionen als in C++ oder Python.
• (Noch) nutzen es weniger Menschen. In der Stack-Overflow-Umfrage 2025 (auf Englisch) gaben deutlich mehr Befragte an, Python (etwa 58 %) oder C++ (etwa 24 %) zu nutzen als Rust (etwa 15 %). Es gibt also weniger erfahrene Rust-Entwickler, die man einstellen, fragen oder im Job von ihnen lernen kann.
• Mehr Code für einfache Dinge. Wie das Channel-Beispiel gezeigt hat, verlangt Rust oft, dass du Dinge explizit hinschreibst, wo andere Sprachen lockerer sind.

Wie geht es weiter?

Du kommst aus einer bestimmten Sprache? Dann helfen dir unsere Leitfäden, dein Wissen gezielt nach Rust zu übertragen: Rust für C#-Entwickler, Rust für Python-Entwickler, Rust für JavaScript- und TypeScript-Entwickler, Rust für Java-Entwickler und Rust für Go-Entwickler.

Zusammenfassung

• Rust bietet Geschwindigkeit auf C++-Niveau mit Speichersicherheit, die beim Kompilieren geprüft wird – und dazu hervorragende eingebaute Werkzeuge.
• Im Vergleich zu C++ verhindert Rust ganze Klassen von Speicherfehlern, bevor das Programm läuft. C++ hat dafür viel mehr bestehenden Code und Bibliotheken.
• Im Vergleich zu Go hat Rust keinen Garbage Collector und stoppt Data Races schon beim Kompilieren. Go ist einfacher und kompiliert viel schneller.
• Im Vergleich zu Python ist Rust viel schneller und prüft Typen vor dem Ausführen. Python ist schneller geschrieben und dominiert Data Science. Mit PyO3 kannst du beide kombinieren.
• Die größten Kosten von Rust sind eine steile Lernkurve, langsameres Kompilieren und ein jüngeres Ökosystem.

Kurzer Check

Kurzer Check

1. Wie verwaltet Rust Speicher ohne Garbage Collector?

Es gibt Speicher nie frei Über Ownership- und Borrowing-Regeln, die beim Kompilieren geprüft werden Das Betriebssystem räumt alle paar Sekunden auf Du musst free() von Hand aufrufen

2. Welcher dieser Punkte ist ein fairer Vorteil von Go gegenüber Rust?

Go verhindert alle Data Races beim Kompilieren Go hat keinen Garbage Collector Go ist eine kleinere Sprache und kompiliert schneller Go ist zur Laufzeit immer schneller

3. In deinem Python-Programm ist eine Funktion viel zu langsam. Was ist ein üblicher Ansatz?

Das ganze Programm in C++ neu schreiben Mehr Type Hints hinzufügen Python lässt sich nie beschleunigen Nur diese Funktion in Rust neu schreiben und sie mit PyO3 aus Python aufrufen

4. Was passiert im Beispiel C++ vs. Rust mit dem Code, der &v[0] festhält und danach etwas zu v hinzufügt?

Rust weigert sich, ihn zu kompilieren Rust kompiliert ihn, und er stürzt zur Laufzeit ab Rust kopiert den Vektor stillschweigend Beide Sprachen lehnen ihn ab

Punkte: 0 / 4

Weiterlesen

• Die Programmiersprache Rust – „Einführung“: für wen Rust gedacht ist, in den Worten des offiziellen Buchs.
• Rust in Android: move fast and fix things – Google Security Blog (auf Englisch): echte Zahlen von einem großen Team, das Rust neben C und C++ einsetzt.
• Stack Overflow Developer Survey 2025 – Admired and Desired (auf Englisch): wie Entwickler über Rust, Go, Python, C++ und andere Sprachen denken.
• Go FAQ – Why did you create a new language? (auf Englisch): die Designziele von Go aus erster Hand – hilfreich, um zu verstehen, wo Go glänzt.
• PyO3 User Guide (auf Englisch): wie du Python-Erweiterungen in Rust schreibst.