So führst du lokale Speech-to-Text-Erkennung auf der CPU mit VibeASR.cpp aus

Die automatische Spracherkennung hat in den letzten Jahren enorme Fortschritte gemacht. Modelle, die früher leistungsstarke GPUs brauchten und inkonsistente Ergebnisse lieferten, liefern heute auf Alltagsrechnern präzise Transkriptionen. 

Gleichzeitig wurden Modelle kleiner, die CPU-Inferenz wurde schneller und die Mehrsprachenunterstützung wuchs. Das ergibt für Nutzer eine bessere Kombination aus Transkriptionsqualität, Tempo, Zugänglichkeit und Datenschutz.

Microsofts VibeVoice-ASR-BitNet ist ein gutes Beispiel für diesen Fortschritt. 

Die optimierte VibeASR.cpp-Runtime ermöglicht es, mehrsprachige Speech-to-Text-Erkennung lokal auf Windows-, Linux- oder macOS-Rechnern auszuführen – ohne dedizierte GPU und ohne Aufnahmen an einen Cloud-Dienst zu senden.

In dieser Anleitung lernst du, wie du VibeASR.cpp installierst und baust, das quantisierte Modell herunterlädst, Audiodateien per Kommandozeile transkribierst, den persistenten Streaming-Server startest und die Gradio-Weboberfläche zum Hochladen oder Aufzeichnen von Sprache nutzt. 

Was ist Microsoft VibeASR.cpp? 

VibeASR.cpp ist Microsofts offizielle C++-Inferenz-Runtime für VibeVoice-ASR-BitNet, ein komprimiertes, mehrsprachiges ASR-Modell für effiziente lokale Inferenz auf CPUs. 

VibeASR.cpp ist kein separates Sprachmodell, sondern stellt die optimierte Engine bereit, um das Modell auszuführen – inklusive Echtzeittranskription ohne dedizierte GPU oder cloudbasierten Spracherkennungsdienst. 

Das macht es geeignet für Laptops, Desktops, Edge-Geräte und andere Systeme mit begrenzten Ressourcen. 

Quelle: microsoft/VibeVoice-ASR-BitNet

Um den Einsatz auf CPUs praktikabel zu machen, ersetzte Microsoft die in der ursprünglichen VibeVoice-ASR-Architektur verwendete Sprachmodell-Komponente Qwen2.5-7B durch das deutlich kleinere Qwen2.5-1.5B-Modell. 

Zudem kommen für die beiden Hauptkomponenten unterschiedliche Quantisierungsmethoden zum Einsatz:

• I8_S für den VAE-Audioencoder
• I2_S für das Sprachmodell, mit höherpräzisen Embeddings

Diese Optimierungen reduzieren die Modellgröße von rund 4,62 GB auf 1,58 GB – damit ist der Einsatz auf Laptops und Desktop-Rechnern gut machbar. 

Trotz der deutlichen Verkleinerung steigt die Wortfehlerrate nur moderat um etwa 1–4 Prozentpunkte gegenüber der größeren Architektur. 

VibeASR.cpp nutzt das ggml-Framework, spezielle CPU-Instruktionen und Operator-Fusion, um die Inferenz zu beschleunigen. 

Laut Microsofts Benchmarks läuft es 1,6–2,3-mal schneller als Whisper.cpp bei vergleichbarer Modellgröße und erreicht auf unterstützten CPUs mit genügend Threads eine schnellere-als-Echtzeit-Transkription.

In Microsofts CPU-Benchmarks erreichte das Modell einen RTF von 0,63 mit vier Threads und 0,42 mit acht Threads – entsprechend rund 1,59× bzw. 2,38× Echtzeit. 

Die gemeldete WER umfasst 8,25 % auf MLC English, 21,36 % auf AMI-Headset-Audio, 25,87 % auf AMI-Fernmikrofon-Audio und 2,41 % auf LibriSpeech clean – ein starker Kompromiss aus Genauigkeit, Modellgröße und CPU-Performance. 

1. Erforderliche Build-Tools installieren

VibeASR.cpp läuft vollständig auf der CPU, eine dedizierte GPU ist nicht nötig. Du brauchst lediglich einen unterstützten Windows-, Linux- oder macOS-Rechner, Python 3.9 oder neuer, Git, einen C++-Compiler und ca. 4 GB freien Speicherplatz für Quellcode, Build-Dateien und Modell.

Für den Build-Prozess werden außerdem CMake und Ninja benötigt. 

Unter Windows ist w64devkit am einfachsten – es liefert Compiler und Build-Tools in einem vorkonfigurierten Terminal. 

Unter Linux lassen sich die benötigten Pakete direkt über den Paketmanager installieren.

Windows

Lade die aktuelle x64-.exe-Datei von der w64devkit-Releaseseite herunter.

Die heruntergeladene Datei ist ein selbstentpackendes Archiv. Führe es aus und entpacke den Ordner an einen einfachen Ort, zum Beispiel nach:

C:\w64devkit

Öffne anschließend:

C:\w64devkit\w64devkit.exe

Damit startest du ein einsatzbereites Terminal mit GCC, CMake, Make und Ninja. Du kannst dieses Terminal für die restlichen Windows-Schritte nutzen, ohne Umgebungsvariablen manuell zu setzen.

Linux

Unter Ubuntu, Debian und verwandten Distributionen installierst du Compiler und Build-Tools mit einem einzigen Befehl:

sudo apt update
sudo apt install build-essential cmake ninja-build git python3 python3-venv

Damit werden der GCC-Compiler, CMake, Ninja, Git, Python und das Paket zum Erstellen einer Python-virtuellen Umgebung installiert.

macOS

Unter macOS installierst du zuerst Apples Kommandozeilen-Tools:

xcode-select --install

Außerdem brauchst du Git, Python 3.9 oder neuer, CMake und Ninja. Am einfachsten installierst du die restlichen Tools mit Homebrew:

brew install git python cmake ninja

2. VibeASR.cpp klonen und die Python-Umgebung einrichten

Die folgenden Schritte sind auf Windows, Linux und macOS identisch. 

Der einzige betriebssystemspezifische Schritt ist der Befehl zum Aktivieren der virtuellen Python-Umgebung.

Öffne dein Terminal, wechsle in den Ordner, in dem du das Projekt speichern willst, und klone das VibeASR.cpp-Repository:

git clone --recursive https://github.com/microsoft/VibeASR.cpp.git
cd VibeASR.cpp

Die Option --recursive lädt auch das benötigte llama.cpp-Submodul. Ohne dieses würden Dateien fehlen, die für den Bau der Inferenz-Runtime notwendig sind.

Erstelle eine virtuelle Python-Umgebung im Projektordner. 

python -m venv .venv

Aktiviere sie mit dem Befehl für dein Betriebssystem.

Windows im w64devkit-Terminal:

. .venv/Scripts/activate

Linux und macOS:

source .venv/bin/activate

Nach der Aktivierung sollte (.venv) vor der Eingabeaufforderung erscheinen. Prüfe, ob Python verfügbar ist: 

python --version

Aktualisiere pip und installiere die Projektabhängigkeiten: 

python -m pip install --upgrade pip

pip install -r requirements.txt

Dazu gehören die Python-Pakete für das Setup-Skript, den Modelldownload und die lokale Gradio-Weboberfläche. 

3. VibeASR.cpp bauen und das Modell herunterladen

VibeASR.cpp enthält ein Setup-Skript, das sowohl den C++-Build-Prozess als auch den Modelldownload übernimmt.

Es kompiliert die Kommandozeilen- und Streaming-Programme, installiert das benötigte GGUF-Paket und lädt die vorquantisierten Modelldateien in das Projektverzeichnis.

Stelle sicher, dass die virtuelle Python-Umgebung aktiv ist, bevor du das Setup-Skript startest.

Unter Linux und macOS führst du aus:

python setup_env.py

Unter Windows startest du im w64devkit-Terminal:

CMAKE_GENERATOR=Ninja python setup_env.py

Mit CMAKE_GENERATOR=Ninja stellst du sicher, dass CMake Ninja verwendet und nicht versucht, Microsoft Visual C++ zu nutzen, das in w64devkit nicht verfügbar ist.

Das Setup-Skript wird:

• Das benötigte gguf-Python-Paket installieren.
• VibeASR.cpp konfigurieren und kompilieren.
• Die Inferenz- und Streaming-Programme bauen.
• Die vorquantisierten VibeASR-Modelldateien herunterladen.
• Die heruntergeladenen Modelle in models/vibeasr speichern.

Nach Abschluss findest du das Haupt-Executable für die Inferenz an folgender Stelle.

Unter Windows:

build/bin/asr_infer.exe

Unter Linux und macOS:

build/bin/asr_infer

Prüfe, ob das Executable erfolgreich gebaut wurde, indem du die verfügbaren Kommandozeilenoptionen anzeigen lässt.

Unter Windows:

./build/bin/asr_infer.exe --help

Unter Linux und macOS:

./build/bin/asr_infer --help

4. Datei- und Streaming-Transkription testen

Jetzt, da Runtime und Modell bereit sind, kannst du zwei Transkriptionsmethoden testen. 

Das Standard-Executable verarbeitet eine Audiodatei und gibt das vollständige Transkript zurück, während der Streaming-Server das Modell geladen hält und die Transkription fortlaufend anzeigt, sobald Tokens generiert werden.

Lade zunächst eine kurze Beispielaufnahme innerhalb des VibeASR.cpp-Projektordners herunter:

curl -L "https://homepages.inf.ed.ac.uk/htang2/notes/speech-samples/103-1240-0000.wav" -o recording.wav

Die Audiodatei wird als recording.wav im aktuellen Projektverzeichnis gespeichert.

Eine Audiodatei transkribieren

Der Standard-Inferenzbefehl lädt Audioencoder und Sprachmodell, verarbeitet die Aufnahme und gibt die vollständige Transkription aus.

Unter Windows führst du aus:

./build/bin/asr_infer.exe \
  --vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
  --lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
  --audio recording.wav \
  -t 6 \
  --greedy

Unter Linux und macOS nutzt du denselben Befehl ohne die Endung .exe:

./build/bin/asr_infer \
  --vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
  --lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
  --audio recording.wav \
  -t 6 \
  --greedy

Die Option -t 6 weist der Inferenz sechs CPU-Threads zu. Passe die Zahl an deinen Prozessor an. 

Die Option --greedy wählt in jedem Decoding-Schritt das wahrscheinlichste Token – das sorgt für konsistente Ergebnisse.

Auf meinem Rechner dauerte die Verarbeitung der 14,085-Sekunden-Aufnahme rund 13,7 Sekunden:

RTF: 0.9726
Speed: approximately 1.03× real time

Der Real-Time-Factor (RTF) vergleicht die Verarbeitungszeit mit der Audiodauer. 

Ein RTF unter 1,0 bedeutet, dass die Aufnahme schneller als in Echtzeit transkribiert wurde. Die Performance variiert je nach Prozessor, Betriebssystem, Thread-Zahl und Aufnahmelänge.

Token-für-Token-Streaming testen

VibeASR.cpp bietet außerdem einen persistenten Streaming-Server. Er lädt die beiden Modelldateien einmal und bleibt aktiv, sodass du mehrere Aufnahmen senden kannst, ohne das Modell jedes Mal neu zu starten und zu laden.

Die Ausgabe ähnelt dem Streaming bei großen Sprachmodellen. 

Statt auf die komplette Transkription zu warten, erscheint der Text schrittweise, während der Decoder jedes Token generiert. 

Einige Tokens stehen für ganze Wörter, andere für Wortteile oder Satzzeichen – sie werden fortlaufend angezeigt, bis das Transkript vollständig ist.

Unter Windows startest du den Server mit:

./build/bin/asr_stream_server.exe \
  --vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
  --lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
  -t 6 \
  --greedy

Unter Linux und macOS führst du aus:

./build/bin/asr_stream_server \
  --vae-model models/vibeasr/vibeasr-vae-encoder-i8_s.gguf \
  --lm-model models/vibeasr/vibeasr-lm-i2_s-embed-q6_k.gguf \
  -t 6 \
  --greedy

Warte, bis der Server die Modelle geladen hat und anzeigt:

---READY---

Gib den Pfad zur Audiodatei ein und drücke Enter:

recording.wav

Die Transkription erscheint dann Token für Token. Wenn die Aufnahme vollständig verarbeitet wurde, zeigt der Server:

---END---

Anschließend kannst du einen weiteren Dateipfad eingeben, ohne die Modelle neu zu laden. Um den Server zu stoppen, tippe:

exit

Dieser persistente Workflow ist besonders nützlich, wenn du mehrere Aufnahmen transkribierst oder VibeASR.cpp an eine Anwendung anbindest, die progressive Transkriptionsausgaben benötigt.

5. Die Weboberfläche starten und testen

VibeASR.cpp enthält eine lokale Gradio-Weboberfläche, über die du Audiodateien hochladen oder per Mikrofon aufnehmen kannst. Der Ablauf ist auf Windows, Linux und macOS identisch, unter Windows enden die Executables auf .exe.

Die für die Oberfläche benötigten Abhängigkeiten – darunter Gradio, SoundFile und NumPy – wurden bereits über requirements.txt installiert.

Stelle zuerst sicher, dass die virtuelle Umgebung aktiv ist.

Windows im w64devkit-Terminal:

. .venv/Scripts/activate

Linux und macOS:

source .venv/bin/activate

Unter Windows startest du die Oberfläche mit:

python demo/gradio_asr_demo.py \
  --port 7860 \
  --bin build/bin/asr_infer.exe \
  --server-bin build/bin/asr_stream_server.exe

Unter Linux und macOS werden die Standardpfade zu den Executables automatisch erkannt:

python demo/gradio_asr_demo.py --port 7860

Die Modellpfade sind im Gradio-Skript für alle Betriebssysteme bereits konfiguriert, du musst sie nicht im Befehl angeben. 

Das Skript unterstützt außerdem getrennte Pfade für das Standard-Executable und den Streaming-Server.

Öffne folgende Adresse in deinem Browser:

http://127.0.0.1:7860

Die Oberfläche erkunden

Die Oberfläche erlaubt dir:

• Das CPU-Modell auszuwählen.
• Die Anzahl der CPU-Threads festzulegen.
• Zwischen Online- und Offline-Verarbeitung zu wechseln.
• Greedy-Decoding zu aktivieren oder Temperatur und Top-p anzupassen.
• Eine Audiodatei hochzuladen oder direkt über das Mikrofon aufzunehmen.
• Optionale Hotwords hinzuzufügen, z. B. Namen oder Fachbegriffe.
• Transkript, Audiodauer und Real-Time-Factor anzuzeigen.

Wichtig: Online-Modus bedeutet hier nicht, dass deine Audios an einen Online-Dienst gesendet werden.

Längere Aufnahmen werden schrittweise in Blöcken verarbeitet und – wenn verfügbar – über asr_stream_server gestreamt. 

Im Offline-Modus wird die komplette Datei verarbeitet, bevor das Ergebnis angezeigt wird.

Eine kurze Aufnahme testen

Für den ersten Test habe ich einen kurzen Satz direkt über das Mikrofon aufgenommen und den Offline-Modus mit vier CPU-Threads gewählt.

Ein RTF von 0,9584 bedeutet, dass das Modell pro Sekunde Audio etwa 0,96 Sekunden Rechenzeit benötigt. 

Das entspricht ungefähr 1,04× Echtzeit – die Transkription war also minimal schneller als die tatsächliche Aufnahmedauer.

Eine längere Aufnahme testen

Ich habe die Oberfläche auch mit einer längeren Aufnahme mit rund 109,7 Sekunden Sprache getestet. Das Modell erzeugte das vollständige Transkript und meldete:

RTF: 0.5305
Audio: 109.7s

Das heißt, das Modell brauchte etwa 0,53 Sekunden Rechenzeit pro Sekunde Audio. Die komplette Aufnahme dauerte rund 58 Sekunden zur Transkription – also ungefähr 1,88× Echtzeit.

Fazit

Mich hat beeindruckt, wie praktikabel lokale Spracherkennung geworden ist. 

Selbst auf einer älteren CPU transkribiert VibeASR.cpp Audio nahezu in Echtzeit oder schneller – ohne GPU, ohne viel Speicher und ohne großen Plattenbedarf. 

Das kompilierte Executable lässt sich zudem in eine Python-Anwendung integrieren, hinter einem FastAPI-Endpunkt betreiben oder als Transkriptions-Engine in einem größeren lokalen Tool verwenden.

Die wichtigste Stellschraube ist die Anzahl der CPU-Threads, die du dem Prozess zuweist. 

Außerdem wählst du zwischen dem Online-Modus, der das Transkript fortlaufend streamt, und dem Offline-Modus, der die vollständige Transkription nach der Verarbeitung zurückgibt.

Die Einrichtung könnte noch einfacher sein – insbesondere unter Windows, Linux und macOS. 

Da sich das Projekt weiterentwickelt, rechne ich mit Verbesserungen bei Installation und vorgebauten Binaries. Sobald ein stabiles, eigenständiges Binary verfügbar ist, sehe ich viele weitere lokale Speech-to-Text-Einsätze für dieses Modell.

Schau dir außerdem unser Tutorial zur GPT Live Transcribe API an.