Whisper.cpp vs faster-whisper 2026: Lokale STT-Benchmarks, Setup & GPU-Beschleunigung

Auf einen Blick

• Beide Tools: Basieren auf OpenAIs quelloffenem Whisper-Modell (MIT-Lizenz). Gleiche Genauigkeit – unterschiedliche Laufzeiten.
• whisper.cpp: In C/C++ von Georgi Gerganov entwickelt. Unterstützt CPU (AVX2/NEON), CUDA, Metal (Apple), Vulkan. Kein Python erforderlich.
• faster-whisper: Python-Bibliothek auf Basis von CTranslate2. Unterstützt CPU (int8) und CUDA. Kein Apple Metal-Support.
• Whisper-Modellgrößen: tiny (39M), base (74M), small (244M), medium (769M), large-v3 (1,55B). Alle im GGML- / CTranslate2-Format.
• Bestes Modell für die meisten Anwendungsfälle: Whisper small – 3,4 % WER, läuft in 2 GB RAM, 6-fache Echtzeit auf modernem CPU.
• RTX 4070-Benchmark (large-v3): faster-whisper ~12-fache Echtzeit; whisper.cpp CUDA ~8-fache Echtzeit. faster-whisper gewinnt auf NVIDIA.
• M5 Pro-Benchmark (large-v3): whisper.cpp Metal ~10-fache Echtzeit; faster-whisper nur-CPU ~3-fache Echtzeit. whisper.cpp gewinnt auf Apple.

Warum lokale Spracherkennung?

• Datenschutz: Audio verlässt niemals Ihr Gerät, sodass kein Cloud-Dienstleister an der Transkription beteiligt ist. Pflichten wie Rechtsgrundlage und sichere Speicherung bleiben bei Ihnen.
• Kosten: Keine minutenbasierten Gebühren. Ein Entwickler, der 8 Stunden Meetings pro Woche transkribiert, spart ca. 110–440 €/Monat gegenüber Cloud-STT-Preisen.
• Offline: Funktioniert im Flugzeug, in Sicherheitsbereichen, in Gebieten ohne stabiles Internet. Kein API-Schlüsselmanagement.
• Latenz: Kein Upload/Download-Roundtrip. Für Echtzeit-Sprachinterfaces reduziert lokale Verarbeitung die STT-Latenz von 300–800 ms (Cloud) auf 50–300 ms.
• Anpassbarkeit: Feinabstimmung auf domänenspezifisches Vokabular. Beliebige Modellgröße, die zur Hardware passt.
• Home-Assistant-Integration: Lokal laufendes Whisper bedeutet, dass Aktivierungswörter und Sprachbefehle das Heimnetzwerk nie verlassen. Siehe lokales Whisper in Home Assistant → für das Add-on-Setup, das Cloud-STT vollständig ersetzt.

Whisper-Modellgrößen – Grundlage beider Tools

Distil-Whisper: Die schnellere Alternative

• Parameter: ~756M – etwa halb so viele wie large-v3s 1,55B; passt in ~4 GB VRAM statt ~10 GB.
• Geschwindigkeit: ~6-fache Echtzeit auf RTX 4070 (vs. 1× Referenz für large-v3) – vergleichbar mit medium in der Geschwindigkeit, bei large-v3-naher Genauigkeit.
• WER: ~2,6 % auf Englisch – nur ~0,1 % höher als large-v3s 2,5 %. In der Praxis kaum hörbarer Unterschied bei typischer Sprachqualität.
• Kompatibilität: Funktioniert mit faster-whisper nativ (WhisperModel("distil-large-v3", device="cuda", compute_type="int8")). Für whisper.cpp: Konvertierung ins GGML-Format mit dem distil-whisper GGML-Konvertierungsskript.
• Am besten geeignet für: Batch-Transkriptionsjobs, Server-Deployments mit begrenztem VRAM und alle Anwendungsfälle, bei denen large-v3-Qualität bei medium-Modell-Geschwindigkeit benötigt wird.
• Nicht geeignet für: Mehrsprachige Transkription – distil-large-v3 ist ausschließlich für Englisch optimiert. Für andere Sprachen: large-v3 oder medium verwenden.

whisper.cpp – Der C/C++-Port

• Plattformunterstützung: CPU (AVX2, AVX512, ARM NEON), Apple Metal (Core ML), CUDA (NVIDIA), Vulkan (AMD/Intel GPU), OpenCL.
• Apple-Silicon-Vorteil: whisper.cpp exportiert Modelle ins Core ML-Format und ermöglicht damit Inferenz auf der Apple Neural Engine. Large-v3 läuft mit ~10-facher Echtzeit auf dem M5 Pro über Metal – schneller als jeder Cloud-Roundtrip.
• Installation: Repository klonen, make (oder cmake) ausführen. Vorgefertigte Binaries für gängige Plattformen verfügbar. Keine Python-Abhängigkeit.
• Modell-Download: bash ./models/download-ggml-model.sh base.en – lädt die GGML-Modelldatei herunter (~142 MB für base).
• CLI-Beispiel: ./main -m models/ggml-base.bin -f audio.wav – transkribiert eine WAV-Datei nach stdout. -l de für Deutsch hinzufügen.
• Echtzeit-Stream-Modus: ./stream -m models/ggml-base.bin --step 3000 --length 10000 – transkribiert in 3-Sekunden-Chunks vom Mikrofon.
• Python-Wrapper: pywhispercpp bietet eine Python-Anbindung für whisper.cpp und ermöglicht die Nutzung in Python-Pipelines ohne Verlust der Metal-Beschleunigung.
• Einschränkung: Kein nativer VAD (Sprachaktivitätserkennung). Der Stream-Modus erfordert die Feinabstimmung der Parameter --step und --length für den jeweiligen Anwendungsfall.

# Build from source (macOS / Linux)
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp
make -j4

# Download a model
bash ./models/download-ggml-model.sh large-v3

# Transcribe a file
./main -m models/ggml-large-v3.bin -f recording.wav

# Enable Metal on Apple Silicon (Core ML)
make -j4 WHISPER_COREML=1
./main -m models/ggml-large-v3-encoder.mlmodelc -f recording.wav

whisper.cpp – Aktuelle Version & Updates

• whisper.cpp v1.9.5 (6. Oktober 2026): ggml-Sync auf v0.26.0 mit Updates für CUDA-, Vulkan-, Metal-, SYCL-, OpenCL-, WebGPU- und CPU-Kernels, ein Abbruch-Callback bei der Spracherkennung, Korrektur eines Integer-Overflows bei parallelen Chunk-Offsets und korrekter Fehlercode der CLI, wenn eine Datei fehlschlägt.
• whisper.cpp v1.9.4 (11. September 2026): Der Server liefert jetzt die erkannte Sprache zurück, der Encoder-Callback läuft vor der automatischen Spracherkennung, und Windows on ARM wurde zum Release-Job hinzugefügt.
• whisper.cpp v1.9.3 (20. August 2026): ggml-Sync auf v0.20.2 mit durchgängigen Performance-Verbesserungen, Metal-TQ2_0-Quantisierung, fusionierten CUDA/SYCL-Kernels und ARM/WASI-Korrekturen.
• whisper.cpp v1.9.0–v1.9.2 (Juni–August 2026): Punktreleases in derselben ggml-Sync- und Performance-Linie vor v1.9.3.
• whisper.cpp v1.8.6 (2. Juni 2026): Neu implementiertes ffmpeg-transcode für klarere optionale FFmpeg-Dekodierung komprimierter Audiodateien (MP3, M4A) plus eine Korrektur des CI-Beispielpfads.
• whisper.cpp v1.8.5 (Mai 2026): Verbesserungen beim Streaming-VAD (Sprachaktivitätserkennung), Korrekturen für Server-Parameter-Leaks und Token-Zeitstempel sowie Behebung von Speicherlecks in den Ruby- und VAD-Bindings.
• whisper.cpp v1.8.4 (19. März 2026): Neueste ggml-Synchronisierung mit breiten Performance-Gewinnen, ein neuer -g / --gpu-device-Flag (und GGML_CUDA-Geräteauswahl) zur GPU-Wahl sowie Korrekturen beim UTF-8-Segmentumbruch.
• Nativer VAD ist jetzt in whisper.cpp integriert. Aktuelle Versionen haben einen nativen Pfad zur Sprachaktivitätserkennung ergänzt und verringern damit einen langjährigen Vorteil von faster-whisper – auch wenn die Silero-VAD-Integration von faster-whisper weiterhin gebrauchsfertiger ist.
• faster-whisper v1.2.1 (31. Oktober 2025): Neueste getaggte Version; pip install faster-whisper installiert sie. 2026 gab es keine getaggte Version, der Main-Branch ist aber aktiv: Commits vom 16. Oktober 2026 ergänzen Eingabeprüfungen, etwa einen Fehler für Sprachen, die ein Modell nicht unterstützt. v1.2.0 (August 2025) brachte Unterstützung für distil-large-v3.5.
• CTranslate2 v4.8.3 (13. Oktober 2026): Die Inferenz-Engine unter faster-whisper wird weiter gepflegt. Die v4.8-Linie brachte Windows-ROCm-Korrekturen, Härtung beim Modellladen und eine Korrektur für eine Division durch null in Whisper align(), wenn ein Fenster keine Frames enthält.
• Kein neues Whisper-Modell mit höherer Genauigkeit 2026. OpenAIs neueste mehrsprachige Gewichte bleiben large-v3-turbo (Oktober 2024; 809M Parameter, Decoder von 32 auf 4 Schichten reduziert, MIT-Lizenz), das einen kleinen Qualitätsverlust gegen deutlich mehr Geschwindigkeit eintauscht und in beiden Tools läuft. distil-large-v3 bleibt die rein englische Speed-Option. Updates an beiden Runtimes betreffen Laufzeit und Tooling, nicht die Genauigkeit.

faster-whisper – Der CTranslate2-Port

• Plattformunterstützung: CPU (int8-Quantisierung) und NVIDIA CUDA GPU. Kein Apple Metal-Support – läuft auf Mac nur über CPU.
• int8-Vorteil: CTranslate2 int8-Quantisierung reduziert den VRAM-Bedarf um ~40 % und erhöht die Inferenzgeschwindigkeit um ~2× gegenüber float16 bei vernachlässigbarer WER-Auswirkung (< 0,1 % absolut).
• Installation: pip install faster-whisper – keine Kompilierung erforderlich (Python 3.9+). GPU-Nutzung erfordert NVIDIA cuBLAS für CUDA 12 und cuDNN 9; ältere CUDA-11-/cuDNN-8-Setups müssen ein älteres ctranslate2 (3.24.0) pinnen.
• Integrierter VAD: faster-whisper enthält Silero VAD-Integration, die stille Audiosegmente automatisch überspringt – entscheidend für Echtzeit-Transkriptions-Pipelines.
• Python-nativ: Die direkte Python-API macht es trivial, faster-whisper mit LLMs, Audio-Verarbeitungsbibliotheken und Web-Frameworks zu verbinden.
• Geschwindigkeit: large-v3 int8 auf RTX 4070 mit ~12-facher Echtzeit und ~2,5 GB VRAM. CPU int8 erreicht ~20-fache Echtzeit für das tiny-Modell.
• Batch-Verarbeitung: faster-whisper unterstützt Batch-Inferenz für die effiziente Verarbeitung großer Audio-Archive.
• Einschränkung: Kein Metal-Support auf Mac – läuft auf Apple Silicon nur über CPU mit ~3-facher Echtzeit für large-v3 vs. whisper.cpps ~10-fache mit Metal.

from faster_whisper import WhisperModel

# Load model (downloads automatically on first run)
model = WhisperModel("large-v3", device="cuda", compute_type="int8")

# Transcribe
segments, info = model.transcribe("audio.wav", beam_size=5)

print(f"Detected language: {info.language} (probability: {info.language_probability:.2f})")
for segment in segments:
    print(f"[{segment.start:.2f}s → {segment.end:.2f}s] {segment.text}")

ggml-base.bin per pip beziehen (Python-Setup)

• Binding installieren: pip install pywhispercpp. Für NVIDIA-CUDA-Beschleunigung mit GGML_CUDA=1 pip install git+https://github.com/absadiki/pywhispercpp bauen.
• ggml-base.bin automatisch herunterladen: from pywhispercpp.model import Model, dann lädt model = Model("base") beim ersten Lauf ggml-base.bin von Hugging Face (ggerganov/whisper.cpp) herunter und speichert es zwischen. "base.en" für die rein englische Variante verwenden.
• Manueller Download (CLI-Weg, ohne pip): In einem geklonten whisper.cpp-Repo speichert bash ./models/download-ggml-model.sh base die Datei unter models/ggml-base.bin – dieselbe Datei, die pywhispercpp abruft.
• Direkter Download: curl -L -o ggml-base.bin https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin lädt das Modell ohne Skript. base durch tiny, small, medium oder large-v3 ersetzen.
• Die Pakete nicht verwechseln: pip install openai-whisper installiert OpenAIs ursprüngliches PyTorch-Whisper (es nutzt .pt-Checkpoints, nicht ggml-base.bin). pip install faster-whisper nutzt das CTranslate2-Format. Nur pywhispercpp verarbeitet GGML-ggml-*.bin-Dateien.
• Wo die Datei liegt: pywhispercpp speichert heruntergeladene GGML-Modelle in seinem Modul-Cache (oder einem Pfad, den Sie über Model("base", models_dir="...") übergeben), sodass dieselbe ggml-base.bin über mehrere Läufe wiederverwendet wird – kein erneuter Download.

# 1. Install the pip binding for whisper.cpp
pip install pywhispercpp

# 2. ggml-base.bin downloads automatically on first use
#    from pywhispercpp.model import Model
#    model = Model("base")          # fetches & caches ggml-base.bin (~142 MB)
#    for seg in model.transcribe("audio.wav"):
#        print(seg.text)

# --- Or get ggml-base.bin manually (no pip) ---
# From a cloned whisper.cpp checkout:
bash ./models/download-ggml-model.sh base       # -> models/ggml-base.bin

# Or download the file directly from Hugging Face:
curl -L -o ggml-base.bin \
  https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin

Direktvergleich: Benchmark-Tabelle

Referenz-Benchmark: GPU- vs. CPU-Laufzeiten von faster-whisper

Echtzeit-Transkription einrichten

• whisper.cpp Stream-Modus: ./stream -m models/ggml-small.bin --step 3000 --length 10000 -t 4 ausführen. Verarbeitet 3-Sekunden-Audio-Chunks; ~0,5–1,5 Sekunden Verzögerung mit dem small-Modell. Kein Python erforderlich.
• faster-whisper VAD-Pipeline: vad_filter=True in model.transcribe() verwenden. Silero VAD segmentiert Audio automatisch an Stille-Grenzen – natürlichere Chunks als bei festen Zeitfenstern.
• Praktische Latenz: 0,5–2 Sekunden hinter der Livesprache mit small- oder medium-Modellen. Tiny verwenden für geringste Latenz (< 0,5 Sekunden, aber höherer WER).
• Modellwahl für Echtzeit: small oder base ist der praktische Sweet Spot – schnell genug, um mit der Sprache mitzuhalten, genau genug für sauberes Audio. large-v3 nur für Echtzeit verwenden, wenn eine dedizierte GPU verfügbar ist.
• Mikrofon-Eingabe: whisper.cpp liest Rohaudiosignale über SDL2 oder portaudio. faster-whisper liest Audio-Arrays aus beliebigen Python-Audiobibliotheken (sounddevice, pyaudio, soundfile).
• Stabilität: whisper.cpp stream mode kann bei Stille wiederholte Tokens erzeugen. Mit --suppress-blank und --no-speech-threshold unterdrücken.

Apple Silicon: whisper.cpp gewinnt

• Core ML-Export: ./models/generate-coreml-model.sh large-v3 ausführen, um den Encoder ins Core ML-Format zu exportieren. Dies verlagert die Encoder-Inferenz auf die Apple Neural Engine.
• M5 Pro-Benchmark (large-v3, Metal): ~10-fache Echtzeit. 60 Minuten Audio werden in ~6 Minuten transkribiert. Hinweis: Der M5 Pro wurde im März 2026 eingeführt – dies sind frühe Community-Benchmarks. Die Performance kann sich mit whisper.cpp-Updates verbessern, die für die M5 Neural Engine optimiert sind.
• M3 MacBook Air-Benchmark (large-v3, Metal): ~7-fache Echtzeit. 60 Minuten in ~8,5 Minuten.
• Arbeitsspeicher: Unified Memory bedeutet kein separater VRAM – ein 16 GB M5 Pro kann large-v3 (~3 GB) problemlos neben anderen Prozessen ausführen.
• faster-whisper auf Mac: Nur CPU, int8. Large-v3 mit ~3-facher Echtzeit. Für Batch-Transkription über Nacht nutzbar, aber nicht für Echtzeit oder zeitkritische Workflows.
• Empfehlung: whisper.cpp für alle Mac-STT-Aufgaben verwenden. pywhispercpp hinzufügen, wenn Python-Integration bei gleichzeitiger Metal-Beschleunigung benötigt wird.

NVIDIA GPU: faster-whisper gewinnt

• RTX 4070 (12 GB)-Benchmark (large-v3 int8): ~12-fache Echtzeit, ~2,5 GB VRAM.
• RTX 3060 (12 GB)-Benchmark (large-v3 int8): ~8-fache Echtzeit, ~2,5 GB VRAM.
• RTX 4060 (8 GB)-Benchmark (large-v3 int8): ~7-fache Echtzeit, ~2,5 GB VRAM – passt problemlos.
• int8 vs. float16: int8 ist ~2× schneller und benötigt ~40 % weniger VRAM bei vernachlässigbarem Genauigkeitsverlust. compute_type="int8" auf NVIDIA immer verwenden.
• Batch-Verarbeitung: Der batched=True-Parameter von faster-whisper ermöglicht die parallele Verarbeitung mehrerer Audiodateien und maximiert die GPU-Auslastung bei großen Transkriptionsjobs.
• Python-Pipeline-Integration: faster-whisper fügt sich direkt in LangChain, Haystack und eigene Python-Pipelines ein. Kein Subprocess-Overhead im Vergleich zum Wrapping von whisper.cpp.

Ältere NVIDIA-GPUs (GTX 970): int8 fällt auf float32 zurück

• Was weiterhin funktioniert: Die vorgebauten CTranslate2-Binaries unterstützen NVIDIA-GPUs ab Compute Capability 3.5; eine GTX 970 (5.2) kann faster-whisper daher auf CUDA ausführen, sofern die installierten CUDA- und cuDNN-Bibliotheken zur Version passen (siehe Häufige Probleme).
• Wo GPU-int8 funktioniert: int8 benötigt Compute Capability 7.0 oder höher (Volta und RTX-20-Serie aufwärts) oder genau 6.1 (GTX 1050 bis 1080 Ti, int8_float32). Compute Capability 6.0, 6.2 und alles darunter fällt auf float32 zurück; float16 benötigt 7.0 oder höher.
• Folge für den Speicher: float32 belegt 4 Byte pro Parameter gegenüber 1 Byte bei int8; nach Parameterzahl braucht large-v3 (1,55B) allein für die Gewichte etwa 6 GB — mehr als die 4 GB der GTX 970. Small (244M, etwa 1 GB in float32) passt problemlos; medium (769M, etwa 3 GB) ist grenzwertig.
• Geschwindigkeit: Wir haben keine GTX 970 gemessen, daher gibt es hier keinen Messwert. Erwarten Sie float32-Durchsatz deutlich unter den RTX-4070-int8-Werten dieses Leitfadens und testen Sie tiny, base und small mit Ihrem eigenen Audio.
• Unterstützte Typen prüfen: ctranslate2.get_supported_compute_types("cuda") listet die Compute-Typen auf, die CTranslate2 auf Ihrer Karte akzeptiert.
• Alternativen: CPU-int8 (device="cpu", compute_type="int8") funktioniert auf jeder modernen x86-CPU, und die quantisierten GGML-Modelle von whisper.cpp (etwa ggml-large-v3-q5_0.bin, rund 3–4 GB) sind der übliche Weg, größere Modelle in 4 GB unterzubringen — prüfen Sie den CUDA- oder Vulkan-Build auf Ihrer Karte.

import ctranslate2
from faster_whisper import WhisperModel

# Which compute types does this GPU accept?
print(ctranslate2.get_supported_compute_types("cuda"))

# On compute capability < 6.1 (e.g. GTX 970), request float32 explicitly so nothing is converted silently
model = WhisperModel("small", device="cuda", compute_type="float32")

Whisper auf dem Raspberry Pi 5: tiny, base & small

• Whisper small auf dem Pi 5: Etwa 0,4–0,6× Echtzeit auf der CPU (ein 10-Minuten-Clip dauert ~17–25 Minuten). Genau mit 3,4 % WER, aber zu langsam für Live-Untertitelung – für nächtliche/Batch-Transkription verwenden.
• Whisper base auf dem Pi 5: Etwa Echtzeit bis ~2× mit Multithreading (-t 4). Der praktische Sweet Spot für Live-Transkription auf dem Pi, mit akzeptablen 5,0 % WER.
• Whisper tiny auf dem Pi 5: Schnellste Option, komfortabel schneller als Echtzeit für den Live-Einsatz, zum Preis höherer 7,6 % WER. Am besten für Wake-Word- und Kurzbefehl-Erkennung.
• Quantisierte Modelle verwenden: bash ./models/download-ggml-model.sh small-q5_0 senkt den RAM-Bedarf und beschleunigt die Inferenz bei minimalem Genauigkeitsverlust – wichtig beim geteilten Speicher des Pi 5.
• faster-whisper auf dem Pi 5: Installierbar (pip install faster-whisper, CPU int8) und wettbewerbsfähig für Batch-Jobs, aber das leichtere C-Binary von whisper.cpp ist die verbreitetere Embedded-Wahl.
• Thermik: Anhaltende Transkription belastet die CPU des Pi 5 stark – verwenden Sie aktive Kühlung, um thermisches Throttling zu vermeiden, das diese Werte verschlechtert.

Wann welches Tool verwenden?

Über whisper.cpp und faster-whisper hinaus

• WhisperX: Basiert auf faster-whisper und fügt wortgenaue Zeitstempel sowie Sprecherdiarisierung hinzu – es wird identifiziert, welcher Sprecher was gesagt hat. Am besten für: Meeting-Transkription mit Sprecher-Labels, Podcast-Bearbeitung und Interview-Transkripte. Installation mit pip install whisperx und Hugging-Face-Token für das Diarisierungsmodell.
• insanely-fast-whisper: Ein Hugging Face Transformers Pipeline-Wrapper mit Flash-Attention-2-Unterstützung für deutlich schnellere GPU-Inferenz als standard faster-whisper auf NVIDIA-Hardware. Am besten für: Batch-Verarbeitung großer Audio-Archive auf NVIDIA-GPUs. Erfordert eine Flash-Attention-2-kompatible GPU (Ampere oder neuer: RTX 3000+, A100, H100).

Häufige Probleme und Lösungen

• CUDA-Versionskonflikt: Aktuelle faster-whisper-Versionen benötigen cuBLAS für CUDA 12 und cuDNN 9. Wer an älteren Bibliotheken hängt, pinnt ctranslate2: pip install --force-reinstall ctranslate2==4.4.0 (CUDA 12 mit cuDNN 8) oder 3.24.0 (CUDA 11 mit cuDNN 8). CUDA-Version prüfen mit nvcc --version.
• Metal-Modell-Export schlägt fehl: Xcode Command Line Tools müssen installiert sein – xcode-select --install ausführen. Das Core ML-Exportskript erfordert das Python-Paket coremltools: pip install coremltools.
• Halluzination bei Stille: Beide Tools können bei stillen Audiosegmenten wiederholte Füll-Tokens erzeugen. --no-speech-threshold 0.6 im whisper.cpp Stream-Modus verwenden oder vad_filter=True in faster-whispers model.transcribe(), um stille Segmente automatisch zu überspringen.
• Speichermangel bei large-v3: Auf int8-Quantisierung in faster-whisper wechseln (compute_type="int8") – reduziert VRAM von ~5 GB (float16) auf ~2,5 GB. Bei whisper.cpp: quantisierte GGML-Variante verwenden (z. B. ggml-large-v3-q5_0.bin), was den Speicher auf ~3–4 GB reduziert.
• Unleserliche Ausgabe bei nicht-englischen Aufnahmen: Keine .en-Modellvarianten (tiny.en, base.en) für nicht-englische Sprache verwenden – diese sind English-only. Mehrsprachige Modelle (base, small, medium, large-v3) verwenden und die Sprache explizit angeben: -l de in whisper.cpp oder language="de" in faster-whisper.
• Langsame CPU-Inferenz: Sicherstellen, dass die CPU AVX2-Instruktionen unterstützt (für optimierte CPU-Inferenz erforderlich). Prüfen mit grep avx2 /proc/cpuinfo unter Linux oder sysctl machdep.cpu.features auf Mac. CPUs ohne AVX2 greifen auf generisches SIMD zurück und sind 2–3× langsamer.

Häufig gestellte Fragen

Quellen

• whisper.cpp auf GitHub — Quellcode, Build-Anleitungen, Modell-Download-Skripte und Metal/Core ML-Setup-Guide.
• faster-whisper auf GitHub — Quellcode, Python-API-Dokumentation und Benchmark-Ergebnisse.
• distil-whisper/distil-large-v3 auf Hugging Face — Modellkarte, Benchmark-Ergebnisse und Nutzungshinweise für die destillierte Whisper-Variante.
• WhisperX auf GitHub — Wortgenaue Zeitstempel und Sprecherdiarisierung basierend auf faster-whisper.
• insanely-fast-whisper auf GitHub — Flash-Attention-2 Whisper-Pipeline für maximalen NVIDIA-GPU-Durchsatz.
• OpenAI Whisper auf GitHub — Originales Whisper-Modell, Paper und Modellkarten für alle Größen.
• OpenAI Whisper Paper (Radford et al., 2022) — „Robust Speech Recognition via Large-Scale Weak Supervision." Quelle der WER-Werte.
• CTranslate2-Dokumentation — Quantisierungsdetails, Hardware-Unterstützung und int8-Optimierungsgrundlagen.
• CTranslate2-Dokumentation zur Quantisierung — Welche Compute-Typen welche GPU-Compute-Capability unterstützt (Grundlage des GTX-970-Abschnitts).
• faster-whisper-README-Benchmarks — 13-Minuten-Laufzeiten für GPU und CPU im Referenz-Benchmark sowie die aktuellen CUDA-12-/cuDNN-9-Anforderungen.
• openai/whisper-large-v3-turbo auf Hugging Face — Model Card: 809M Parameter, 4 Decoder-Schichten, MIT-Lizenz.
• Bill Mill: aktualisierter Benchmark mlx_whisper vs. whisper.cpp — Unabhängiger large-v3-turbo-Zeitvergleich auf Apple Silicon.
• whisper.cpp-Releases — Release Notes zu v1.9.4 und v1.9.5.

Weiterführende Artikel

• Lokale TTS und Voice Cloning 2026: Piper vs Coqui vs XTTS v2 — Der TTS-Begleiter: transkribierte Texte wieder in Sprache umwandeln, offline.
• Vollständig offline Sprachassistenten erstellen 2026 — Whisper STT mit einem lokalen LLM und Piper TTS zu einer vollständigen Sprach-Pipeline verbinden.
• Lokale multimodale KI-Pipeline 2026 — Vision-Modelle neben STT und TTS für einen vollständigen lokalen multimodalen Stack hinzufügen.
• Lokaler LLM Hardware-Guide — GPU- und RAM-Anforderungen für die vollständige Sprach- + LLM-Pipeline.
• Lokalen Sprachassistenten auf dem Smartphone erstellen — Mobile Version: WhisperKit auf iPhone, Layla auf Android.