Rust-Fehler E0601: `main` function not found in crate (main fehlt)

E0601 bedeutet: Rust wollte ein Programm bauen, hat aber nicht gefunden, wo es anfängt. Jedes Rust-Programm beginnt in einer Funktion, die genau main heißt und auf der obersten Ebene von src/main.rs steht. Fehlt sie, ist sie falsch geschrieben oder steckt sie in einem Modul, bekommst du diesen Fehler. Er ist sehr häufig, wenn du ein Snippet aus einem Tutorial oder aus der Doku einer Library kopierst, und er ist immer schnell behoben. (Diese Seite gehört zur Reihe Rust-Compilerfehler einfach erklärt.)

Die Fehlermeldung

error[E0601]: `main` function not found in crate `main`
 --> src/main.rs:7:2
  |
7 | } // ❌ Ende der Datei, und nirgends ein `fn main`
  |  ^ consider adding a `main` function to `src/main.rs`

Auf Deutsch: „Im Crate main wurde keine Funktion main gefunden.“ Der Hinweis sagt: „Füge src/main.rs eine Funktion main hinzu.“

Dieses Programm erzeugt den Fehler:

fn total(prices: &[u32]) -> u32 {
    prices.iter().sum()
}

fn average(prices: &[u32]) -> u32 {
    total(prices) / prices.len() as u32
} // ❌ Ende der Datei, und nirgends ein `fn main`

Was sie bedeutet

Das ^ zeigt auf das Ende der Datei, direkt hinter die letzte }. Das sieht seltsam aus, ergibt aber Sinn: rustc hat die ganze Datei nach fn main durchsucht und das Ende erreicht, ohne eins zu finden. Es gibt keine falsche Zeile, auf die er zeigen könnte – das Problem ist eine Zeile, die gar nicht da ist.

Der Crate-Name in der Meldung hängt davon ab, wie du baust. Diese Ausgabe stammt von rustc src/main.rs, also heißt das Crate nach der Datei main. Mit cargo run siehst du stattdessen den Paketnamen aus Cargo.toml, zum Beispiel `main` function not found in crate `shop`. Gleicher Fehler, gleiche Lösungen.

Das ist wie ein Theaterstück mit tollen Szenen, aber ohne „1. Akt, 1. Szene“. Die Schauspieler sind bereit, aber niemand weiß, wo die Vorstellung beginnt.

Warum Rust das macht

Ein Rust-Binary (ein Programm, das du startest) braucht einen festen Einstiegspunkt. Wenn du das Programm startest, ruft das Betriebssystem main auf, und alles andere passiert, weil main es aufruft. Rust rät nicht: nicht die erste Funktion in der Datei, nicht eine Funktion namens start, nicht Main. Der Name muss genau main lauten, kleingeschrieben, auf der obersten Ebene des Crates.

Code, der für sich allein kein Programm ist, etwa eine Sammlung von Hilfsfunktionen für anderen Code, ist eine Library (Bibliothek). Eine Library hat kein main und steht stattdessen in src/lib.rs. E0601 heißt oft: Der Code ist in Ordnung, steckt aber in der falschen Art von Crate. Siehe Binary- und Library-Crate zusammen und Erste Schritte.

So behebst du den Fehler

Lösung 1: Eine `main`-Funktion ergänzen (oder ihren Namen korrigieren)

Nimm diese Lösung in den meisten Fällen: Du hast Funktionen von irgendwo kopiert, oder du hast angefangen, Hilfsfunktionen zu schreiben, und main fehlt noch. Ergänze fn main() und ruf deinen Code von dort auf:

fn total(prices: &[u32]) -> u32 {
    prices.iter().sum()
}

fn average(prices: &[u32]) -> u32 {
    total(prices) / prices.len() as u32
}

fn main() { // ✅ hier startet das Programm
    let prices = [250, 199, 1200];
    println!("Summe: {} Cent", total(&prices));
    println!("Durchschnitt: {} Cent", average(&prices));
}

Ausgabe:

Summe: 1649 Cent
Durchschnitt: 549 Cent

▶ Selbst ausprobieren

Du hast schon ein main? Dann prüf, wie es geschrieben ist. fn Main(), fn mian() oder fn main_() ergeben genau denselben Fehler E0601, denn für Rust sind das einfach andere Funktionen. Groß- und Kleinschreibung zählt, und es muss eine Funktion sein: fn main(), mit Klammern.

Lösung 2: `main` aus dem Modul holen

Nimm diese Lösung, wenn in der Meldung the main function must be defined at the crate level steht. Du hast ein main, aber es steckt in einem mod, ist also eigentlich app::main und nicht der Einstiegspunkt des Programms:

error[E0601]: `main` function not found in crate `main`
 --> src/main.rs:5:2
  |
5 | }
  |  ^ the main function must be defined at the crate level (in `src/main.rs`)
  |
note: here is a function named `main`
 --> src/main.rs:2:5
  |
2 |     pub fn main() { // ❌ in einem Modul, nicht auf oberster Ebene
  |     ^^^^^^^^^^^^^
  = note: you have one or more functions named `main` not defined at the crate level
  = help: consider moving the `main` function definitions

Auf Deutsch: „Die Funktion main muss auf der Ebene des Crates definiert sein (in src/main.rs).“ Die note zeigt dir, wo eine Funktion namens main steht, und die Hilfe schlägt vor, sie zu verschieben.

Das Programm dahinter:

mod app {
    pub fn main() { // ❌ in einem Modul, nicht auf oberster Ebene
        println!("Der Shop startet ...");
    }
}

Setz das echte main auf die oberste Ebene. Der Code im Modul kann dort bleiben; gib ihm einen klareren Namen wie run und ruf ihn aus main auf:

mod app {
    pub fn run() {
        println!("Der Shop startet ...");
    }
}

fn main() { // ✅ auf der obersten Ebene von src/main.rs
    app::run();
}

Ausgabe:

Der Shop startet ...

▶ Selbst ausprobieren

Das gilt genauso für Module in anderen Dateien: Ein pub fn main() in src/app.rs ist app::main, niemals der Einstiegspunkt. Siehe Module.

Lösung 3: Eine Library daraus machen, wenn der Code nicht allein laufen soll

Nimm diese Lösung, wenn der Code eine Sammlung von Hilfsfunktionen für anderen Code ist und es nichts zu „starten“ gibt. Libraries haben kein main. Leg das Projekt mit --lib an:

cargo new --lib cart     # legt src/lib.rs an: eine Library, kein main nötig
cargo new shop           # legt src/main.rs mit fn main() an: ein Programm

Schreib die Hilfsfunktionen in src/lib.rs, markiere mit pub, was anderer Code benutzen darf, und prüf sie mit Tests statt mit cargo run:

pub fn total(prices: &[u32]) -> u32 {
    prices.iter().sum()
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn adds_prices() {
        assert_eq!(total(&[3, 4]), 7);
    }
}

Für eine Library nimmst du cargo build oder cargo test. cargo run funktioniert dort nicht; es meldet error: a bin target must be available for `cargo run` – so sagt Cargo „in diesem Paket gibt es kein Programm“. Willst du beides, leg neben src/lib.rs eine src/main.rs an. Sie benutzt die Library über den Paketnamen:

fn main() {
    let sum = cart::total(&[250, 199, 1200]);
    println!("total: {} cents", sum);
}

Jetzt gibt cargo run total: 1649 cents aus. Siehe Binary- und Library-Crate zusammen und Tests.

Wo du ihn oft siehst

Ein Snippet aus der Doku oder einem Tutorial einfügen. Viele Beispiele zeigen nur eine Funktion oder ein struct, kein ganzes Programm. In src/main.rs eingefügt, ergeben sie E0601. Lösung: Pack die Zeilen, die etwas tun, in fn main() { ... }, und lass Funktionen und Structs außerhalb. (Der Rust Playground merkt, wenn main fehlt, und bietet an, den Code zu bauen statt ihn auszuführen. Dort siehst du diesen Fehler also meistens nicht.)

Dein Editor markiert die letzte Zeile von main.rs rot. rust-analyzer führt im Hintergrund cargo check aus, also siehst du E0601 in der letzten Zeile, während du noch Hilfsfunktionen schreibst. Das ist in Ordnung: Die Markierung verschwindet, sobald du fn main() ergänzt.

Zusätzliche Programme in src/bin/. Jede Datei in src/bin/, etwa src/bin/import.rs, ist ein eigenes Programm, und jedes braucht sein eigenes fn main(). Lösung: Ergänze main in dieser Datei, oder verschieb gemeinsamen Code nach src/lib.rs. Siehe den Link zu den Cargo Targets unten.

Kurzer Check

1. Deine src/main.rs enthält fn Main() { ... }. Was sagt cargo run?

2. Du schreibst Hilfsfunktionen für anderen Code, es gibt nichts zu starten. Was ist der richtige Aufbau?

3. rustc meldet „the main function must be defined at the crate level“. Was ist falsch?

Punkte: 0 / 3

Weiterlesen

E0601 – Rust error codes index (auf Englisch): die offizielle Erklärung dieses Fehlers.
Hallo Welt – Das Rust-Buch: deine erste main-Funktion und warum jedes Programm dort beginnt.
Pakete und Crates – Das Rust-Buch: Binary-Crates und Library-Crates, src/main.rs und src/lib.rs.
Cargo Targets – The Cargo Book (auf Englisch): Libraries, Binaries, src/bin/ und wie Cargo jedes davon findet.
Main functions – The Rust Reference (auf Englisch): die genauen Regeln für main, auch dafür, wo es stehen darf.