# Compiler vs. Interpreter: Unterschied erklärt

> Ein Computer versteht nur Maschinencode aus Nullen und Einsen, kein für Menschen lesbares Programm. Ein Compiler übersetzt den gesamten Quellcode vorab in ein ausführbares Programm – schnell in der Ausführung, aber unflexibel. Ein Interpreter übersetzt den Code Zeile für Zeile während der Ausführung – flexibler, aber langsamer. Viele moderne Sprachen kombinieren beide Ansätze.

**Autor:** Mr. Benjamin · **Beruf:** IT-Grundlagen
**Veröffentlicht:** 2026-07-16 · **Aktualisiert:** 2026-07-16
**Quelle:** https://yellowbluetech.de/blog/compiler-vs-interpreter

---

Du schreibst Programmcode in einer für Menschen lesbaren Sprache – aber der Computer versteht davon kein Wort. Irgendjemand muss übersetzen. Ob das ein Compiler oder ein Interpreter tut, macht einen großen Unterschied, und die Frage ist ein Prüfungsklassiker.

## Warum muss Code überhaupt übersetzt werden?

Ein Prozessor versteht nur **Maschinencode** – nackte Befehle aus [Nullen und Einsen](/blog/bit-byte-binaersystem). Der Quellcode, den du schreibst (`if`, `while`, `alter = 18`), ist für Menschen gemacht, nicht für die Hardware. Zwischen beidem muss übersetzt werden.

> **Merksatz**
>
> **Quellcode** ist für Menschen lesbar, **Maschinencode** für den Prozessor ausführbar. Ein Übersetzer bringt das eine ins andere – entweder alles auf einmal (Compiler) oder Stück für Stück beim Ausführen (Interpreter).

## Was macht ein Compiler?

Ein Compiler übersetzt den **kompletten Quellcode auf einmal**, bevor das Programm läuft. Das Ergebnis ist eine fertige, ausführbare Datei, die der Computer direkt starten kann.

> **Merksatz**
>
> Der Compiler ist wie ein **übersetztes Buch**: Einmal komplett übersetzt, kann es beliebig oft und schnell gelesen werden. Die Arbeit passiert vorher, einmalig.

Vorteil: Das fertige Programm läuft **schnell**, weil beim Start nichts mehr übersetzt werden muss. Nachteil: Nach jeder Änderung am Code muss neu übersetzt werden, und das Programm ist an eine bestimmte Plattform gebunden. Klassisch compilierte Sprachen sind C und C++.

## Was macht ein Interpreter?

Ein Interpreter übersetzt den Code **Zeile für Zeile während der Ausführung**. Es entsteht keine eigenständige Programmdatei – der Interpreter muss immer mitlaufen.

> **Merksatz**
>
> Der Interpreter ist wie ein **Simultandolmetscher**: Er übersetzt live, Satz für Satz, während gesprochen wird. Das ist flexibel, kostet aber bei jedem Durchlauf erneut Zeit.

Vorteil: **flexibel** – Code lässt sich sofort testen, ohne vorher zu übersetzen, und läuft überall dort, wo der Interpreter vorhanden ist. Nachteil: **langsamer**, weil bei jeder Ausführung neu übersetzt wird. Eine typische interpretierte Sprache ist Python.

## Der direkte Vergleich

| Merkmal | Compiler | Interpreter |
| --- | --- | --- |
| Übersetzung | alles vorab | Zeile für Zeile beim Ausführen |
| Ergebnis | fertige, ausführbare Datei | keine, Interpreter läuft mit |
| Ausführung | schnell | langsamer |
| Fehler zeigen sich | beim Übersetzen | erst beim Ausführen der Stelle |
| Beispiel | C, C++ | Python |

> **Prüfungstipp**
>
> Ein wichtiger Unterschied für die Prüfung: Der **Compiler meldet Fehler schon beim Übersetzen**, bevor das Programm überhaupt läuft. Der **Interpreter stolpert erst über den Fehler, wenn er die betreffende Zeile erreicht**. Deshalb kann ein interpretiertes Programm scheinbar problemlos starten und erst mittendrin abstürzen.

## Und wo liegt Java?

Viele moderne Sprachen kombinieren beide Ansätze. Java etwa wird zuerst in einen plattformunabhängigen Zwischencode (**Bytecode**) compiliert, den dann zur Laufzeit eine virtuelle Maschine ausführt.

> **Hinweis**
>
> Dieser Mittelweg verbindet die Vorteile: Der Bytecode ist einmal vorübersetzt und dadurch schneller als reine Interpretation, bleibt aber plattformunabhängig – dasselbe Programm läuft auf jedem System, das die passende Laufzeitumgebung hat. Der Leitsatz von Java lautet nicht umsonst „einmal schreiben, überall ausführen".

## Selbstkontrolle

**Frage:** Wann zeigt sich bei einem compilierten Programm ein Syntaxfehler im Code?

- [x] Schon beim Übersetzen, bevor das Programm läuft.
- [ ] Erst wenn die fehlerhafte Zeile ausgeführt wird.
- [ ] Nie, compilierte Programme haben keine Fehler.
- [ ] Nur wenn der Interpreter fehlt.

**Erklärung:** Der Compiler übersetzt den gesamten Quellcode vor der Ausführung. Dabei prüft er ihn und meldet Syntaxfehler bereits beim Übersetzen – das Programm entsteht gar nicht erst. Ein Interpreter dagegen würde den Fehler erst bemerken, wenn er die betreffende Zeile zur Laufzeit erreicht.

## Häufige Fragen

### Was ist der Unterschied zwischen Quellcode und Maschinencode?

Quellcode ist der von Menschen geschriebene Programmtext in einer Programmiersprache. Maschinencode besteht aus den Befehlen, die der Prozessor direkt ausführen kann, dargestellt in Nullen und Einsen. Ein Übersetzer wandelt Quellcode in Maschinencode um, weil die Hardware den Quellcode selbst nicht versteht.

### Ist compiliert immer besser als interpretiert?

Nein, beide haben ihren Platz. Compilierte Programme laufen schneller und eignen sich für rechenintensive Anwendungen. Interpretierte Sprachen sind flexibler, schneller zum Ausprobieren und plattformunabhängiger. Welcher Ansatz besser passt, hängt vom Einsatzzweck ab.

### Was ist Bytecode?

Bytecode ist eine Zwischenstufe zwischen Quellcode und Maschinencode. Er ist bereits vorübersetzt, aber noch nicht an eine bestimmte Hardware gebunden. Eine virtuelle Maschine führt den Bytecode zur Laufzeit aus. Dadurch läuft dasselbe Programm auf verschiedenen Systemen, ohne neu compiliert zu werden.

### Muss ich als Programmierer selbst compilieren?

In compilierten Sprachen stößt du den Übersetzungsvorgang an, meist mit einem einzigen Befehl oder Klick in der Entwicklungsumgebung. Bei interpretierten Sprachen entfällt dieser Schritt, du startest den Code direkt. Moderne Werkzeuge nehmen dir den Vorgang weitgehend ab.

**Weiterlesen:** [Variablen und Datentypen einfach erklärt](/blog/variablen-und-datentypen) · [Fehlerbehandlung mit Exceptions](/blog/fehlerbehandlung-exceptions) · [OOP-Grundlagen: Klasse, Objekt, Prinzipien](/blog/oop-grundlagen) · [Programmablaufplan (PAP) und Struktogramm](/blog/algorithmus-struktogramm-pap)

## Das Wichtigste in Kürze

- Ein Prozessor versteht nur **Maschinencode**, nicht den lesbaren **Quellcode**.
- Ein **Compiler** übersetzt **alles vorab** in eine ausführbare Datei – schnelle Ausführung.
- Ein **Interpreter** übersetzt **Zeile für Zeile** beim Ausführen – flexibel, aber langsamer.
- Der **Compiler meldet Fehler vorab**, der **Interpreter erst zur Laufzeit**.
- Sprachen wie **Java** kombinieren beides über **Bytecode**.