Whisper.cpp einrichten: 53.000 Sterne, 12 Schritte [2026]

Wer heute Meetings, Podcasts oder Interviews transkribieren will, landet fast automatisch bei einer Cloud-API mit Kosten pro Minute und einer Datenschutzfrage im Nacken. whisper.cpp löst beide Probleme: Es führt OpenAIs Whisper-Spracherkennung komplett offline aus, in C/C++ geschrieben, ohne Python-Umgebung und ohne dass ein einziges Audio-Byte das eigene Gerät verlässt. Das Projekt von Georgi Gerganov (bekannt auch für llama.cpp) läuft mittlerweile auf mehr als 53.000 GitHub-Sternen (Stand: 3. September 2026, Quelle: GitHub-Repository ggml-org/whisper.cpp) und wird aktiv weiterentwickelt, zuletzt mit dem Release v1.8.5 am 29. Mai 2026. Dieses Tutorial führt Sie in 12 Schritten von der ersten Installation bis zur automatisierten Transkriptions-Pipeline für Meetings, inklusive GPU-Beschleunigung, Quantisierung und Server-Betrieb.

Der Reiz von whisper.cpp liegt in der Kombination aus Einfachheit und Reichweite. Statt eines mehrere Gigabyte großen Python-Stacks mit CUDA-Treibern, virtuellen Umgebungen und Abhängigkeitskonflikten braucht das Projekt nur einen C++-Compiler und CMake. Genau diese Schlankheit hat dazu geführt, dass whisper.cpp heute in Entwickler-Tools, mobilen Apps, Browser-Erweiterungen und sogar auf Einplatinencomputern zum Einsatz kommt. Für Redaktionen, Kanzleien, Praxen und IT-Abteilungen in Deutschland, Österreich und der Schweiz ist das ein doppelter Vorteil: geringere Betriebskosten und die Möglichkeit, sensible Sprachdaten dauerhaft im eigenen Netz zu behalten.

Was ist whisper.cpp und warum lohnt sich der lokale Einsatz?

whisper.cpp ist ein Port von OpenAIs Whisper-Modell nach C/C++, ohne Abhängigkeit von PyTorch oder einer Python-Laufzeitumgebung. Das Projekt nutzt die gleiche ggml-Bibliothek, die auch llama.cpp antreibt, und verwendet exakt dieselben Modellgewichte wie das Original. Die Genauigkeit bleibt dadurch identisch, verändert hat sich nur die Inferenz-Engine. Für Unternehmen in Deutschland und der DACH-Region ist das ein handfester Vorteil: Transkripte aus Kundengesprächen, Behandlungsnotizen oder internen Meetings müssen das eigene Netzwerk nie verlassen, was die DSGVO-Compliance erheblich vereinfacht.

Das Projekt steht unter MIT-Lizenz und wird im GitHub-Repository ggml-org/whisper.cpp gepflegt. Unterstützt werden macOS (Intel und Apple Silicon), iOS, Android, Linux, FreeBSD, WebAssembly, Windows und sogar Raspberry-Pi-Boards. Auf Apple-Geräten nutzt whisper.cpp native Metal- und Core-ML-Beschleunigung, auf x86-Prozessoren AVX-Instruktionen und auf POWER9/10-Systemen VSX. Damit deckt ein einziges Projekt so gut wie jede Zielplattform ab, von der Entwickler-Workstation bis zum Embedded-Gerät.

Die technische Basis von whisper.cpp ist ggml, eine schlanke Tensor-Bibliothek, die Gerganov ursprünglich für genau diesen Zweck entwickelt hat: neuronale Netze ohne schwergewichtige Frameworks auf gewöhnlicher Consumer-Hardware laufen zu lassen. Dieselbe Bibliothek bildet mittlerweile das Fundament für llama.cpp und eine ganze Reihe weiterer Projekte, die große Sprachmodelle lokal ausführen. Wer sich also in whisper.cpp einarbeitet, versteht damit gleichzeitig die Grundlage vieler anderer lokaler KI-Werkzeuge, etwa für RAG-Pipelines oder eigene LLM-Benchmarks.

Der Praxisnutzen zeigt sich vor allem bei wiederkehrenden Transkriptionsaufgaben: Meeting-Mitschnitte, Untertitel für Videos, Sprachnotizen in Support-Tickets oder automatisierte Protokolle. Weil whisper.cpp lokal läuft, entfallen laufende API-Kosten pro Minute Audio komplett. Es fällt einmalig der Aufwand für die Einrichtung an, danach läuft die Transkription so oft wie nötig ohne zusätzliche Rechnung.

Ein weiterer Punkt, der in Einführungsartikeln oft untergeht: whisper.cpp ist kein isoliertes Projekt, sondern Teil eines größeren Ökosystems rund um die ggml-Bibliothek. Wer bereits mit lokalen Sprachmodellen arbeitet, etwa über Ollama oder direkt über LM Studio, findet in whisper.cpp die passende Ergänzung für den Audio-Teil einer Pipeline. Transkribierter Text lässt sich anschließend direkt an ein lokales Sprachmodell weiterreichen, etwa um Meeting-Notizen automatisch zusammenzufassen, ohne dass Audio oder Text das eigene System verlassen.

Voraussetzungen: Hardware, Software und Versionen

Bevor es losgeht, sollten folgende Voraussetzungen erfüllt sein. Die Liste ist bewusst knapp gehalten, denn genau das ist einer der großen Vorteile von whisper.cpp gegenüber Python-basierten Alternativen.

• Ein C++-Compiler: GCC oder Clang unter Linux/macOS, MSVC oder MinGW unter Windows
• CMake ab Version 3.14 (aktuelle Distributionen liefern meist eine neuere Version aus)
• Git zum Klonen des Repositorys
• Mindestens 2 GB freier Arbeitsspeicher für kleinere Modelle, 8 GB oder mehr für große Modelle
• Optional: eine Apple-Silicon-CPU (M1 bis M5) für Metal/Core-ML-Beschleunigung, eine Nvidia-GPU für CUDA/cuBLAS oder eine POWER9/10-CPU für VSX
• Circa 100 MB bis 3 GB freier Speicherplatz, abhängig von der gewählten Modellgröße
• Ein aktuelles Betriebssystem: macOS, Windows 10/11, eine gängige Linux-Distribution oder FreeBSD

Die im Tutorial verwendete Version ist whisper.cpp v1.8.5 (veröffentlicht am 29. Mai 2026), das bislang letzte stabile Release laut der offiziellen Release-Seite des Projekts. Vorangegangen waren v1.8.4 am 19. März 2026 und v1.8.3 am 15. Januar 2026, was zeigt, wie regelmäßig das Projekt aktualisiert wird. Der Quellcode wird laufend weiterentwickelt, mit Commits bis in den September 2026 hinein, sodass sich ein Blick auf die main-Branch lohnt, wenn Sie die absolut neuesten Fixes benötigen.

Die schlanke Abhängigkeitsliste ist kein Zufall, sondern bewusstes Designziel des Projekts. Wo eine Python-basierte Alternative meist PyTorch, mehrere Gigabyte an CUDA-Bibliotheken und eine gepflegte virtuelle Umgebung voraussetzt, kommt whisper.cpp mit dem nackten Compiler und CMake aus. Das macht das Projekt auch für Umgebungen interessant, in denen Python aus Sicherheits- oder Compliance-Gründen gar nicht erst installiert werden darf, etwa in isolierten Netzwerksegmenten oder auf gehärteten Servern.

Schritt 1 bis 3: Repository klonen und whisper.cpp kompilieren

Schritt 1: Repository klonen

Der erste Schritt ist ein einfacher Git-Klon. Öffnen Sie ein Terminal und führen Sie folgenden Befehl aus:

git clone https://github.com/ggml-org/whisper.cpp.git
cd whisper.cpp

Damit liegt der komplette Quellcode inklusive Beispielprogrammen, Modell-Download-Skripten und der ggml-Bibliothek lokal vor.

Schritt 2: Build-Tools prüfen und installieren

Prüfen Sie, ob CMake und ein Compiler vorhanden sind. Unter Ubuntu/Debian reicht dafür ein Aufruf des Paketmanagers:

sudo apt update
sudo apt install -y build-essential cmake git

# macOS mit Homebrew
brew install cmake

# Versionen pruefen
cmake --version
g++ --version

Unter Windows empfiehlt sich Visual Studio mit der C++-Workload oder alternativ MinGW-w64, beide werden vom Build-System offiziell unterstützt.

Schritt 3: Mit CMake kompilieren

Der Build-Prozess läuft über CMake und erzeugt optimierte Binärdateien im Ordner build:

cmake -B build
cmake --build build -j --config Release

Der Parameter -j nutzt automatisch alle verfügbaren CPU-Kerne, wodurch der Build auf einem modernen Rechner meist in ein bis zwei Minuten fertig ist. Nach erfolgreichem Durchlauf liegt die ausführbare Datei unter build/bin/whisper-cli.

Schritt 4 und 5: Modell herunterladen und erste Transkription

whisper.cpp bringt ein eigenes Download-Skript mit, das die Modelle im ggml-Format aus dem offiziellen Hugging-Face-Repository lädt. Für den Einstieg eignet sich das base-Modell, ein guter Kompromiss aus Geschwindigkeit und Genauigkeit:

./models/download-ggml-model.sh base

# Fuer deutsche Audiodateien reicht auch das mehrsprachige Modell
./models/download-ggml-model.sh small

Anschließend folgt die erste Transkription mit einer der mitgelieferten Beispieldateien:

./build/bin/whisper-cli -m models/ggml-base.bin -f samples/jfk.wav

Die Ausgabe im Terminal sieht typischerweise so aus:

[00:00:00.000 --> 00:00:11.000]   And so my fellow Americans, ask not what your
country can do for you, ask what you can do for your country.

whisper_print_timings:     load time =   245.12 ms
whisper_print_timings:    total time =  1204.67 ms

Für eigene Audiodateien im deutschen Sprachraum genügt es, den Dateipfad hinter -f auszutauschen. whisper.cpp akzeptiert WAV-Dateien mit 16-kHz-Sampling nativ, andere Formate müssen vorher mit ffmpeg konvertiert werden.

Schritt 6: Die richtige Modellgröße wählen

whisper.cpp unterstützt sämtliche offiziellen Whisper-Modellgrößen von OpenAI: tiny, base, small, medium, large sowie die neueren Varianten large-v3 und large-v3-turbo. Letzteres wurde von OpenAI als schlankere Alternative zu large-v3 veröffentlicht und bietet laut dem offiziellen openai/whisper-Repository bei 809 Millionen Parametern eine rund achtfache relative Geschwindigkeit gegenüber dem vollen large-Modell, bei nur minimalem Genauigkeitsverlust. Die folgende Tabelle fasst die wichtigsten Eckdaten zusammen:

Modell	Größe (ggml, fp16)	Sprachen	Empfohlener Einsatz
tiny	ca. 75 MB	mehrsprachig	Prototyping, Echtzeit auf schwacher Hardware
base	ca. 142 MB	mehrsprachig	Guter Einstieg, brauchbare Genauigkeit
small	ca. 466 MB	mehrsprachig	Alltagstranskription, Meetings
medium	ca. 1,5 GB	mehrsprachig	Höhere Genauigkeit, mehr Rechenzeit
large-v3	ca. 2,9 GB	mehrsprachig	Maximale Genauigkeit, produktive Einsätze
large-v3-turbo	ca. 1,5 GB	mehrsprachig	Fast so genau wie large-v3, deutlich schneller

Quantisierte Varianten reduzieren den Speicherbedarf zusätzlich: Laut den offiziellen Modell-Metadaten im whisper.cpp-Repository schrumpft large-v3-turbo von rund 1,5 GiB im vollen fp16-Format auf etwa 547 MiB in der q5_0-Quantisierung. Für die meisten deutschsprachigen Anwendungsfälle ist small oder medium ein guter Startpunkt, während large-v3-turbo sich für produktive Systeme mit begrenztem Zeitbudget eignet.

Schritt 7: GPU-Beschleunigung mit Metal, Core ML und CUDA aktivieren

Auf Apple-Silicon-Macs nutzt whisper.cpp automatisch Metal, sobald der Standard-Build ausgeführt wird, da Apple Silicon laut Projekt-Dokumentation als “first-class citizen” behandelt wird, optimiert über ARM-NEON, das Accelerate-Framework, Metal und Core ML. Wer zusätzlich das Core-ML-Modell nutzen will, muss dieses vorab konvertieren:

# Core-ML-Modell erzeugen (nur macOS)
./models/generate-coreml-model.sh base

# Build mit Core-ML-Unterstuetzung
cmake -B build -DWHISPER_COREML=1
cmake --build build -j --config Release

Auf Systemen mit Nvidia-GPU lässt sich die Inferenz über cuBLAS beschleunigen. Der Build-Befehl dafür sieht so aus:

cmake -B build -DGGML_CUDA=1
cmake --build build -j --config Release

Voraussetzung dafür ist ein installiertes CUDA-Toolkit sowie die passenden Nvidia-Treiber. Ohne dedizierte GPU greift whisper.cpp automatisch auf die CPU-Pfade mit AVX-Optimierung zurück, was für kleinere und mittlere Modelle in der Praxis oft bereits ausreichend schnell ist.

Schritt 8: Modelle quantisieren für mehr Tempo

Quantisierung reduziert die Präzision der Modellgewichte, etwa von 16-Bit-Floats auf 4- oder 5-Bit-Integer, und verkleinert dadurch sowohl den Speicherbedarf als auch die Rechenzeit. whisper.cpp bringt dafür ein eigenes Kommandozeilenwerkzeug mit:

./build/bin/quantize models/ggml-base.bin models/ggml-base-q5_0.bin q5_0

Wie stark sich Quantisierung auf die Genauigkeit auswirkt, hat eine akademische Analyse auf arXiv untersucht: Beim Base-Modell lag die Wortfehlerrate (WER) im fp32-Referenzlauf bei 0,0199 (98,0 % Genauigkeit) und einer Modellgröße von 141,11 MB. Nach INT8-Quantisierung blieb die WER identisch bei 0,0199, bei einer auf 77,99 MB reduzierten Modellgröße. Die INT4-Variante erreichte sogar eine leicht bessere WER von 0,0159 (98,4 % Genauigkeit) bei nur 44,33 MB Größe. Für die meisten Anwendungsfälle bedeutet das: Quantisierung kostet praktisch keine Genauigkeit, spart aber erheblich Speicher und Rechenzeit.

whisper.cpp bietet dabei mehrere Quantisierungsstufen zur Auswahl, die sich im Kürzel nach dem Modellnamen unterscheiden, etwa q4_0, q5_0, q5_1 oder q8_0. Die Ziffer beschreibt grob die Bitbreite pro Gewicht, während die Endung 0 oder 1 auf unterschiedliche Rundungsschemata verweist. Als Faustregel gilt: q5_0 bietet für die meisten Sprachaufnahmen den besten Kompromiss aus Geschwindigkeit und Genauigkeit, q4_0 eignet sich für stark eingeschränkte Hardware wie ältere Laptops oder Einplatinencomputer, und q8_0 ist die richtige Wahl, wenn selbst kleinste Genauigkeitsverluste vermieden werden sollen, aber trotzdem etwas Speicher gespart werden soll.

Schritt 9: Live-Transkription per Mikrofon-Stream einrichten

Für Echtzeit-Anwendungen wie Live-Untertitel liefert whisper.cpp ein Streaming-Beispiel mit, das kontinuierlich Audio vom Mikrofon aufnimmt und in kurzen Segmenten transkribiert. Dafür muss zunächst SDL2 als Abhängigkeit für die Audioaufnahme installiert werden:

# Ubuntu/Debian
sudo apt install -y libsdl2-dev

# Stream-Beispiel bauen
cmake -B build -DWHISPER_SDL2=ON
cmake --build build -j --config Release

# Live-Transkription starten
./build/bin/whisper-stream -m models/ggml-base.bin -t 6 --step 500 --length 5000

Der Parameter --step steuert, wie oft ein neuer Audioabschnitt verarbeitet wird (in Millisekunden), --length definiert die Fenstergröße. Kleinere Werte liefern schnellere, aber tendenziell fragmentiertere Zwischenergebnisse.

Schritt 10: Server-Modus für API-Zugriff einrichten

Wer whisper.cpp in eine bestehende Anwendung integrieren möchte, ohne die CLI direkt aufzurufen, nutzt am besten den mitgelieferten HTTP-Server. Dieser stellt eine zu OpenAIs Transkriptions-API kompatible Schnittstelle bereit:

cmake -B build -DWHISPER_BUILD_SERVER=ON
cmake --build build -j --config Release

./build/bin/whisper-server -m models/ggml-small.bin --host 0.0.0.0 --port 8080

Eine Transkriptionsanfrage lässt sich anschließend per curl an den lokalen Server schicken:

curl 127.0.0.1:8080/inference \
  -H "Content-Type: multipart/form-data" \
  -F file="@meeting.wav" \
  -F response_format="json"

Damit lässt sich whisper.cpp problemlos hinter einen Reverse Proxy stellen und von mehreren internen Anwendungen gleichzeitig nutzen, ganz ohne Cloud-Anbindung. Bei mehreren gleichzeitigen Anfragen lohnt sich ein Test der tatsächlichen Kapazität, bevor der Server produktiv geschaltet wird: Da jede Transkription CPU- beziehungsweise GPU-Ressourcen bindet, sollte die Anzahl paralleler Requests an die verfügbare Hardware angepasst werden, etwa durch eine vorgeschaltete Warteschlange, die Anfragen seriell abarbeitet, statt den Server mit zu vielen gleichzeitigen Jobs zu überlasten.

Schritt 11: Mehrsprachige Transkription und Sprachsteuerung

Alle multilingualen Whisper-Modelle erkennen die gesprochene Sprache automatisch. Für deutschsprachige Aufnahmen kann es dennoch sinnvoll sein, die Sprache explizit zu setzen, um Fehlerkennungen bei kurzen oder verrauschten Clips zu vermeiden:

./build/bin/whisper-cli -m models/ggml-small.bin -f interview.wav -l de

# Uebersetzung ins Englische statt Transkription
./build/bin/whisper-cli -m models/ggml-small.bin -f interview.wav -l de --translate

Der Parameter -l de erzwingt die deutsche Sprache, --translate übersetzt die Eingabe zusätzlich ins Englische, unabhängig von der Ausgangssprache. Für rein englischsprachige Inhalte existieren zudem spezielle .en-Modellvarianten wie tiny.en oder base.en, die laut Projekt-Dokumentation eine geringfügig höhere Genauigkeit bei englischem Audio liefern als ihre multilingualen Pendants.

Schritt 12: Batch-Verarbeitung und Docker-Deployment

Für die Verarbeitung ganzer Ordner mit Audiodateien lohnt sich ein einfaches Shell-Skript, das alle WAV-Dateien nacheinander durchläuft:

#!/bin/bash
for datei in eingang/*.wav; do
  name=$(basename "$datei" .wav)
  ./build/bin/whisper-cli -m models/ggml-small.bin -f "$datei" \
    -l de -otxt -of "ausgabe/$name"
done

Der Parameter -otxt schreibt das Ergebnis als reine Textdatei, weitere Optionen wie -osrt oder -ovtt erzeugen Untertiteldateien im SRT- oder VTT-Format. whisper.cpp bringt außerdem ein offizielles Docker-Image mit, das sich für containerisierte Deployments eignet, etwa auf einem internen Server, der Audiodateien aus einer Warteschlange abarbeitet, ohne dass auf dem Host selbst Build-Tools installiert werden müssen.

Für unterschiedliche Weiterverarbeitungsszenarien lohnt sich ein Blick auf alle verfügbaren Ausgabeformate. Die folgende Übersicht zeigt, welcher Parameter welches Format erzeugt und wofür es sich eignet:

Parameter	Ausgabeformat	Typischer Einsatzzweck
-otxt	Reiner Text	Protokolle, Volltextsuche, Archivierung
-osrt	SubRip-Untertitel (.srt)	Videountertitel für Schnittprogramme
-ovtt	WebVTT (.vtt)	Untertitel für Webplayer und Streaming
-ocsv	CSV mit Zeitstempeln	Weiterverarbeitung in Tabellenkalkulation oder Skripten
-oj	JSON	Programmatische Weiterverarbeitung, API-Integration

Bindings für Python, Node.js und weitere Sprachen

Nicht jedes Projekt profitiert von einer reinen Kommandozeilen-Integration. Rund um die C/C++-Kernbibliothek von whisper.cpp hat sich eine breite Sammlung an Community-Bindings entwickelt, die den Aufruf aus anderen Programmiersprachen heraus erlauben, ohne einen eigenen Build-Prozess für jedes Projekt aufzusetzen. Dazu zählen Wrapper für Python, Node.js, Java, Swift und Go, die die kompilierte Bibliothek über native Schnittstellen ansprechen und die Ergebnisse als gewöhnliche Objekte der jeweiligen Sprache zurückliefern.

Für mobile Entwicklung ist besonders die Swift- und Objective-C-kompatible Anbindung interessant, da whisper.cpp offiziell iOS als Zielplattform unterstützt. Dadurch lassen sich Sprach-zu-Text-Funktionen direkt in eine iOS-App einbauen, ohne dass Audiodaten das Gerät verlassen, ein Argument, das gerade bei Apps mit sensiblen Inhalten wie Diktier- oder Notizfunktionen den Ausschlag geben kann. Auf der Serverseite bevorzugen die meisten Teams dagegen den bereits vorgestellten HTTP-Server, da er sprachunabhängig über eine einfache REST-Schnittstelle angesprochen werden kann und keine zusätzliche Bibliothek in der Zielanwendung benötigt.

Datenschutz und DSGVO: Warum lokale Transkription in Deutschland zählt

Sprachaufnahmen gelten regelmäßig als personenbezogene Daten im Sinne der DSGVO, insbesondere wenn Stimmen identifizierbaren Personen zugeordnet werden können oder Gesprächsinhalte Gesundheits-, Finanz- oder sonstige sensible Informationen enthalten. Sobald eine Audiodatei zur Transkription an einen externen Cloud-Dienst außerhalb der EU übertragen wird, entsteht ein zusätzlicher Prüfpunkt für Auftragsverarbeitungsverträge, Standardvertragsklauseln und die Frage, wo die Daten tatsächlich verarbeitet und gespeichert werden.

whisper.cpp umgeht diese Prüfung von vornherein, weil die gesamte Verarbeitung auf der eigenen Hardware stattfindet. Für Kanzleien, Arztpraxen, Personalabteilungen und Behörden, die Gespräche protokollieren müssen, aber keine Drittanbieter-Cloud einbinden dürfen oder wollen, ist das ein entscheidendes Argument. Wichtig bleibt trotzdem, dass die eigene Infrastruktur ausreichend abgesichert ist: Zugriffsrechte auf die Transkript-Ordner, Verschlüsselung ruhender Daten und ein sauberes Löschkonzept für temporäre Audiodateien gehören weiterhin zu den Pflichtaufgaben, die eine lokale Lösung nicht automatisch mitliefert.

Für die interne Dokumentation empfiehlt es sich, den Einsatz von whisper.cpp im Verzeichnis der Verarbeitungstätigkeiten festzuhalten, auch wenn keine Datenübermittlung an Dritte stattfindet. Das erleichtert spätere Auskunftsersuchen Betroffener und zeigt gegenüber Aufsichtsbehörden, dass die Verarbeitung bewusst lokal gehalten wurde, statt aus Bequemlichkeit auf einen Cloud-Dienst zurückzugreifen. Gerade im Kontext von NIS2 und ähnlichen Regelwerken, die von Unternehmen zunehmend eine lückenlose Nachvollziehbarkeit ihrer Datenverarbeitung verlangen, ist eine klar dokumentierte, lokale Transkriptionslösung ein Pluspunkt bei jedem Audit.

Komplettes Praxisprojekt: Automatisierte Meeting-Transkription

Alle bisherigen Schritte lassen sich zu einer vollständigen Pipeline zusammensetzen, die Meeting-Aufnahmen automatisch transkribiert und als durchsuchbares Textprotokoll ablegt. Das folgende Skript kombiniert Formatkonvertierung, Transkription mit erzwungener deutscher Sprache und Untertitel-Export in einem Durchlauf:

#!/bin/bash
# meeting-transkribieren.sh
# Nutzung: ./meeting-transkribieren.sh aufnahme.m4a

EINGABE="$1"
NAME=$(basename "$EINGABE" | cut -d. -f1)
MODELL="models/ggml-small-q5_0.bin"

# 1. Audioformat auf 16-kHz-WAV konvertieren
ffmpeg -y -i "$EINGABE" -ar 16000 -ac 1 -c:a pcm_s16le "tmp_$NAME.wav"

# 2. Transkription mit deutschem Sprachmodell und Untertiteln
./build/bin/whisper-cli -m "$MODELL" -f "tmp_$NAME.wav" \
  -l de -otxt -osrt -of "protokolle/$NAME"

# 3. Temporaere Datei entfernen
rm "tmp_$NAME.wav"

echo "Transkript gespeichert unter protokolle/$NAME.txt"

Dieses Skript lässt sich per Cronjob oder als Watch-Skript an einen Ordner koppeln, in den Meeting-Aufnahmen automatisch abgelegt werden, etwa aus einer Konferenzsoftware heraus. Mit dem quantisierten small-Modell verarbeitet ein aktueller Rechner eine 30-minütige Aufnahme je nach Hardware innerhalb weniger Minuten, komplett offline und ohne dass Meeting-Inhalte je einen externen Server erreichen.

Für den vollautomatischen Betrieb reicht ein einfacher Cronjob, der den Eingangsordner regelmäßig prüft:

# Crontab-Eintrag: alle 15 Minuten neue Aufnahmen verarbeiten
*/15 * * * * /home/nutzer/whisper.cpp/verarbeite-eingang.sh >> /var/log/whisper-cron.log 2>&1

Nach einem erfolgreichen Durchlauf liegt im Protokollordner eine fertige Textdatei mit einem Aufbau wie diesem:

[00:00:03.200 --> 00:00:09.800]   Willkommen zum Wochenmeeting, heute geht es um
die Q3-Zahlen und die geplante Produktvorstellung im Oktober.
[00:00:09.800 --> 00:00:15.400]   Zunaechst zum Umsatz: Wir liegen sieben Prozent
ueber dem Plan aus dem letzten Quartal.

Diese Textdateien lassen sich anschließend problemlos in eine Volltextsuche, ein Wiki oder ein Projektmanagement-Tool importieren, ganz ohne manuelles Abtippen.

Wie schnell läuft whisper.cpp in der Praxis wirklich?

Offizielle, durchgängig aktuelle Benchmark-Tabellen veröffentlicht das Projekt selbst nicht, stellt dafür aber mit whisper-bench und dem Skript bench.py eigene Werkzeuge bereit, mit denen sich die Geschwindigkeit auf der eigenen Hardware objektiv messen lässt. Der entscheidende Kennwert dabei ist der Real-Time-Faktor (RTF): Ein RTF von 1,0 bedeutet, dass eine Minute Audio auch eine Minute Rechenzeit benötigt, während ein niedrigerer Wert schnellere Verarbeitung anzeigt.

Ein 2026 veröffentlichter Praxistest auf Apple Silicon berichtet für eine lokale Mac-Konfiguration mit dem large-v3-turbo-Modell einen RTF von rund 0,14, was bedeutet, dass sieben Sekunden Audio in rund einer Sekunde verarbeitet wurden, also etwa siebenmal schneller als Echtzeit. Solche Werte hängen naturgemäß stark von CPU-Generation, aktivierten Backends und gewählter Modellgröße ab und sollten als Orientierung, nicht als garantierter Wert für jede Konfiguration verstanden werden. Wer belastbare Zahlen für die eigene Infrastruktur benötigt, sollte whisper-bench nach der Installation direkt gegen die eigene Zielhardware laufen lassen, bevor eine Kapazitätsplanung für den Produktivbetrieb erfolgt.

Whisper.cpp im Vergleich zu openai-whisper und faster-whisper

Alle drei Projekte verwenden dieselben Whisper-Modellgewichte, unterscheiden sich aber deutlich in der Inferenz-Engine und damit in Geschwindigkeit und Einsatzumgebung. Laut Benchmark-Daten aus dem offiziellen faster-whisper-Repository von SYSTRAN ergibt sich auf CPU (8 Threads, small-Modell, fp32, beam size 5) folgendes Bild: openai/whisper benötigt für eine Testdatei 6:58 Minuten, whisper.cpp schafft dieselbe Datei in 2:05 Minuten. Auf der GPU zeigt sich ein ähnliches Muster: Bei einem 13-minütigen Testclip mit dem large-v2-Modell (fp16, beam size 5) kommt faster-whisper auf 1:03 Minuten, während openai/whisper 2:23 Minuten benötigt, ein Faktor von rund 2,27.

Kriterium	whisper.cpp	openai-whisper (Python)	faster-whisper
Sprache/Runtime	C/C++, ggml	Python, PyTorch	Python, CTranslate2
Beste Hardware	Apple Silicon, CPU, Embedded	Beliebig, Referenzimplementierung	Nvidia-GPU
Abhängigkeiten	Minimal, kein Python nötig	PyTorch, ffmpeg, Python	CTranslate2, Python
CPU-Tempo (small, fp32, 8 Threads)	2:05 Min	6:58 Min	schneller als Referenz, GPU-fokussiert
Plattformen	macOS, iOS, Android, Linux, Windows, WebAssembly, Raspberry Pi	Alle mit Python/PyTorch	Linux, Windows, macOS mit Python
Lizenz	MIT	MIT	MIT

Die praktische Empfehlung lautet: whisper.cpp eignet sich am besten für Apple-Silicon-Geräte, reine CPU-Server, mobile Apps und Embedded-Systeme, während faster-whisper auf Systemen mit dedizierter Nvidia-GPU und bestehender Python-Infrastruktur oft die schnellere Wahl ist. openai-whisper selbst bleibt vor allem als Referenzimplementierung und für schnelle Experimente relevant, ist aber im Produktivbetrieb in der Regel die langsamste der drei Optionen.

Für die Entscheidung zwischen den drei Optionen lohnt sich ein Blick auf die vorhandene Infrastruktur, bevor eine Wahl getroffen wird. Wer bereits eine Python-basierte Machine-Learning-Pipeline mit Nvidia-GPUs betreibt, spart sich mit faster-whisper eine zusätzliche Build-Toolchain. Wer dagegen eine schlanke, abhängigkeitsarme Lösung für heterogene Endgeräte sucht, etwa eine gemischte Flotte aus MacBooks, Linux-Servern und Raspberry-Pi-Sensoren, profitiert von der einheitlichen C/C++-Basis von whisper.cpp. In beiden Fällen bleibt die Transkriptionsqualität selbst identisch, da alle drei Werkzeuge dieselben Whisper-Gewichte laden.

Anwendungsfälle: Wo sich whisper.cpp in der Praxis lohnt

Über die reine Meeting-Transkription hinaus deckt whisper.cpp eine ganze Reihe wiederkehrender Aufgaben ab, bei denen sich der einmalige Einrichtungsaufwand schnell auszahlt. Redaktionen nutzen es, um Interview-Mitschnitte in durchsuchbaren Text zu verwandeln, bevor daraus ein Artikel entsteht. Podcast-Produzenten erzeugen damit automatisch Shownotes und Untertitel, ohne für jede Episode eine externe Transkriptionsagentur zu beauftragen. Support-Teams transkribieren aufgezeichnete Kundenanrufe, um Stichworte für die Qualitätssicherung zu extrahieren, während Hochschulen und Forschungseinrichtungen qualitative Interviews für die spätere Auswertung in Text überführen.

Auch die Barrierefreiheit profitiert direkt: Automatisch erzeugte Untertitel im SRT- oder VTT-Format machen Lehrvideos, Firmenpräsentationen oder Konferenzaufzeichnungen für gehörlose und schwerhörige Zuschauer zugänglich, ohne dass für jedes Video ein manueller Untertitel-Dienstleister beauftragt werden muss. Entwickler wiederum bauen mit dem WebAssembly-Modul von whisper.cpp Diktierfunktionen direkt in Webanwendungen ein, die vollständig im Browser laufen und keinerlei Serverkommunikation für die eigentliche Spracherkennung benötigen.

Wer bereits eine selbst gehostete Oberfläche für lokale Sprachmodelle betreibt, etwa Open WebUI, kann den von whisper.cpp erzeugten Text direkt als Eingabe weiterreichen, um Zusammenfassungen, Übersetzungen oder Aufgabenlisten aus einem Meeting automatisch generieren zu lassen. Damit entsteht eine vollständig lokale Kette von Audio über Text bis zur weiterverarbeiteten Ausgabe, ohne dass an irgendeiner Stelle ein externer Dienst eingebunden werden muss.

Häufige Fehler und Stolperfallen bei whisper.cpp

Beim Einstieg in whisper.cpp tauchen einige Fehler immer wieder auf, meist weil ein Nutzer die Grundannahmen des Projekts überträgt, die für Python-basierte Tools gelten, aber hier nicht zutreffen. Die folgende Liste zeigt die häufigsten Stolperfallen und wie sie sich vermeiden lassen.

• Falsches Audioformat: whisper.cpp erwartet 16-kHz-Mono-WAV-Dateien. MP3-, M4A- oder Stereo-Dateien führen zu Fehlern oder schlechten Ergebnissen, wenn sie nicht vorher mit ffmpeg konvertiert werden.
• Zu großes Modell für die Hardware: Wer large-v3 auf einem älteren Laptop ohne GPU-Beschleunigung nutzt, wartet unnötig lange. Für schwache Hardware sind tiny, base oder small die bessere Wahl.
• Vergessener Build-Flag für GPU-Support: Ohne -DGGML_CUDA=1 oder -DWHISPER_COREML=1 beim CMake-Aufruf läuft whisper.cpp automatisch auf der CPU, selbst wenn eine passende GPU vorhanden ist.
• Fehlende Sprachangabe bei kurzen Clips: Bei Audiodateien unter fünf Sekunden kann die automatische Spracherkennung fehlschlagen. Der Parameter -l de behebt das zuverlässig.
• Veraltete Modelle nach einem Update: Neue whisper.cpp-Versionen ändern gelegentlich das ggml-Modellformat. Nach einem Update sollten Modelle über das Download-Skript neu geladen werden, statt alte Binärdateien weiterzuverwenden.

Troubleshooting: Die häufigsten Probleme lösen

Auch bei sorgfältiger Einrichtung tauchen typische Probleme auf. Hier die wichtigsten mit direkter Lösung.

1. “cmake: command not found”: CMake ist nicht installiert oder nicht im PATH. Unter Ubuntu hilft sudo apt install cmake, unter macOS brew install cmake.
2. Build bricht mit Compiler-Fehler ab: Meist liegt es an einer zu alten GCC-Version. Ein Upgrade auf GCC 11 oder neuer löst die meisten Kompatibilitätsprobleme.
3. “failed to open model file”: Der Pfad hinter -m stimmt nicht. Prüfen Sie mit ls models/, ob die Modelldatei tatsächlich heruntergeladen wurde.
4. Transkription liefert nur Leerzeichen oder Müll: Häufig ein Zeichen für eine falsche Samplerate. Konvertieren Sie die Datei explizit mit ffmpeg -i input.mp3 -ar 16000 -ac 1 output.wav.
5. Sehr langsame Verarbeitung trotz moderner Hardware: Prüfen Sie, ob der Build tatsächlich mit GPU-Flags kompiliert wurde. Ein einfacher Test: ./build/bin/whisper-cli --help zeigt in der Kopfzeile an, welche Backends aktiv sind.
6. Speicherfehler (“out of memory”) bei großen Modellen: Wechseln Sie auf eine quantisierte Variante wie q5_0 oder q4_0, die deutlich weniger RAM benötigt.
7. Streaming-Beispiel lässt sich nicht bauen: SDL2 fehlt. Unter Linux hilft sudo apt install libsdl2-dev, unter macOS brew install sdl2.
8. Server antwortet nicht auf Port 8080: Prüfen Sie, ob eine Firewall den Port blockiert, und ob der Server tatsächlich mit --host 0.0.0.0 statt nur 127.0.0.1 gestartet wurde, wenn von einem anderen Rechner zugegriffen werden soll.

Fortgeschrittene Tipps für den Produktivbetrieb

Wer whisper.cpp über den reinen Testbetrieb hinaus einsetzen will, profitiert von einigen zusätzlichen Kniffen. Erstens lohnt sich ein Blick auf die Diarisierungs-Unterstützung: whisper.cpp bietet mit tinydiarize-kompatiblen Modellen die Möglichkeit, Sprecherwechsel grob zu markieren, was für Meeting-Protokolle mit mehreren Teilnehmern nützlich ist, auch wenn eine vollständige Sprechererkennung damit nicht erreicht wird.

Zweitens sollte die Beam-Size an den Anwendungsfall angepasst werden. Ein kleinerer Wert (etwa --beam-size 1) beschleunigt die Verarbeitung erheblich und eignet sich für Echtzeitanwendungen, während ein höherer Wert (5 oder mehr) bei Offline-Transkriptionen leicht bessere Ergebnisse liefert, auf Kosten der Rechenzeit. Drittens lässt sich whisper.cpp dank WebAssembly-Unterstützung direkt im Browser ausführen, ganz ohne Server-Backend, was sich für datenschutzsensible Web-Anwendungen anbietet, bei denen Audio nie den Client verlässt.

Viertens hilft eine Kombination aus Quantisierung und dem large-v3-turbo-Modell dort, wo sowohl Geschwindigkeit als auch Genauigkeit zählen: Die Turbo-Variante liegt laut OpenAI-Dokumentation nur minimal hinter large-v3 bei der Genauigkeit, läuft aber deutlich schneller, und lässt sich zusätzlich quantisieren, um auch auf schwächerer Hardware praxistauglich zu bleiben. Fünftens sollte bei produktiven Deployments der Server-Modus hinter einem Reverse Proxy mit TLS betrieben werden, insbesondere wenn mehrere interne Dienste über das Netzwerk zugreifen.

Sechstens lohnt sich ein regelmäßiger Blick auf die main-Branch des Repositorys, da whisper.cpp laut Commit-Historie fortlaufend Performance-Verbesserungen erhält, zuletzt mit einem als Wartungs-Release beschriebenen Update am 20. August 2026. Wer produktiv auf whisper.cpp setzt, sollte deshalb einen Prozess für regelmäßige Rebuilds einplanen, statt eine einmal kompilierte Version dauerhaft unverändert zu betreiben. Siebtens empfiehlt sich für sehr lange Aufnahmen, etwa mehrstündige Konferenzen, eine Vorab-Segmentierung der Audiodatei in kleinere Abschnitte, da sich dadurch Zwischenergebnisse früher auswerten lassen und ein Absturz mitten in der Verarbeitung nicht die gesamte Aufnahme unbrauchbar macht.

Zusammenfassung: In 12 Schritten zur eigenen Transkriptions-Pipeline

Von der ersten Installation bis zur automatisierten Meeting-Pipeline sind es genau zwölf Schritte: Repository klonen, Build-Tools installieren, mit CMake kompilieren, ein Modell herunterladen, die erste Transkription starten, die passende Modellgröße wählen, GPU-Beschleunigung aktivieren, quantisieren, Live-Transkription einrichten, den Server-Modus starten, mehrsprachige Ausgabe steuern und schließlich Batch-Verarbeitung samt Docker-Deployment aufsetzen. Jeder einzelne Schritt baut auf dem vorherigen auf, lässt sich aber auch isoliert nutzen, wenn beispielsweise nur eine einmalige Transkription benötigt wird, statt gleich eine vollständige Automatisierung aufzusetzen.

Der größte Unterschied zu Cloud-basierten Alternativen bleibt dabei konstant: Sobald der Build einmal steht und ein Modell heruntergeladen ist, läuft jede weitere Transkription ohne Internetverbindung, ohne laufende Kosten und ohne dass Audiodaten das eigene System verlassen. Für DACH-Unternehmen mit strengen Datenschutzanforderungen ist das oft der eigentliche Auslöser für den Umstieg, die Performance und die Kostenersparnis kommen als willkommener Zusatzeffekt hinzu.

Häufig gestellte Fragen zu whisper.cpp

Ist whisper.cpp kostenlos nutzbar, auch kommerziell?

Ja. Das Projekt steht unter der MIT-Lizenz, die auch die kommerzielle Nutzung ohne Lizenzgebühren erlaubt. Zu beachten bleibt lediglich, dass die Whisper-Modellgewichte selbst separaten Lizenzbedingungen von OpenAI unterliegen, die aber ebenfalls eine breite Nutzung zulassen. Für Unternehmen bedeutet das in der Praxis: Es fallen weder Lizenzkosten für die Software noch nutzungsbasierte Gebühren für die Transkription selbst an, einzig die eigene Hardware und der Einrichtungsaufwand müssen einkalkuliert werden.

Braucht whisper.cpp zwingend eine GPU?

Nein. whisper.cpp ist explizit für effiziente CPU-Inferenz entwickelt und nutzt AVX-Instruktionen auf x86-Prozessoren sowie ARM-NEON auf Apple-Geräten. Eine GPU (Metal, Core ML oder CUDA) beschleunigt die Verarbeitung zusätzlich, ist aber für kleinere und mittlere Modelle keine Voraussetzung.

Wie gut funktioniert whisper.cpp mit deutscher Sprache?

Da whisper.cpp dieselben mehrsprachigen Modellgewichte wie das originale Whisper-Modell verwendet, ist die Genauigkeit für Deutsch identisch zur Python-Referenzimplementierung. Für beste Ergebnisse empfiehlt es sich, die Sprache mit -l de explizit zu setzen und ab dem small-Modell aufwärts zu arbeiten. Dialekte, starke Umgangssprache oder stark verrauschte Aufnahmen bleiben aber, wie bei jedem Spracherkennungssystem, anspruchsvoller als klar gesprochenes Hochdeutsch, weshalb sich bei kritischen Anwendungsfällen eine stichprobenartige manuelle Kontrolle des Transkripts empfiehlt.

Welches Modell sollte ich für den Einstieg wählen?

Für erste Tests eignet sich das base-Modell. Für produktive Meeting-Transkription ist small ein guter Kompromiss aus Tempo und Genauigkeit, während large-v3-turbo dort sinnvoll ist, wo maximale Genauigkeit bei vertretbarer Rechenzeit gefragt ist.

Kann whisper.cpp Sprecher automatisch unterscheiden?

Eine vollständige Sprechererkennung (Diarisierung) ist nicht Teil des Kernprojekts. Mit tinydiarize-kompatiblen Modellen lassen sich grobe Sprecherwechsel markieren, für eine präzise Zuordnung einzelner Sprecher wird üblicherweise eine zusätzliche Diarisierungs-Bibliothek vor- oder nachgeschaltet. Für Meetings mit wenigen, klar unterscheidbaren Stimmen reicht die grobe Sprecherwechsel-Markierung oft schon aus, bei größeren Konferenzrunden mit vielen Teilnehmenden lohnt sich dagegen eine dedizierte Diarisierungslösung im Anschluss an die Transkription.

Wie unterscheidet sich whisper.cpp von faster-whisper?

Beide nutzen dieselben Whisper-Modellgewichte, unterscheiden sich aber in der Inferenz-Engine: whisper.cpp basiert auf einer eigenen C/C++-Implementierung (ggml) und eignet sich besonders für Apple Silicon, CPU-Server und Embedded-Systeme, während faster-whisper auf CTranslate2 aufsetzt und vor allem auf Nvidia-GPUs seine Stärken ausspielt.

Läuft whisper.cpp auch auf einem Raspberry Pi?

Ja, Raspberry Pi wird laut offizieller Projektdokumentation als unterstützte Plattform geführt. Für flüssige Ergebnisse empfiehlt sich dort ein kleineres, quantisiertes Modell wie tiny oder base, da die Rechenleistung deutlich unter der eines Desktop-Systems liegt. Für Bastelprojekte wie einen Offline-Sprachassistenten oder ein kleines Diktiergerät auf Basis eines Einplatinencomputers reicht das erfahrungsgemäß aus, für produktive Meeting-Transkription mit vielen Teilnehmenden sollte dagegen leistungsfähigere Hardware zum Einsatz kommen.

Was kostet der Betrieb von whisper.cpp im Vergleich zu einer Cloud-API?

Da whisper.cpp lokal läuft, entstehen keine laufenden Kosten pro transkribierter Minute. Es fällt lediglich der einmalige Aufwand für Einrichtung und die bereits vorhandene Hardware an. Bei hohem Transkriptionsvolumen amortisiert sich das gegenüber nutzungsbasierten Cloud-APIs in der Regel schnell, insbesondere wenn ohnehin schon Server- oder Arbeitsplatz-Hardware zur Verfügung steht, die für die Transkription mitgenutzt werden kann, statt zusätzliche Cloud-Rechnungen zu erzeugen.