⚠ Translation out of date. See the English CLI reference for Nemotron 3 support.

⚠ Übersetzung veraltet

Die neuesten Informationen zu VoiceChat-Werkzeugaufrufen und Leistung finden Sie in der englischen Version.

CLI-Referenz

Breeze TTS 2 · BreezeTTS

Englische und chinesische Sprachsynthese mit Stimmdesign, Klonen und Steuerung einer Referenzstimme sowie Audiostreaming (MLX BF16/8-bit, 24 kHz; nur Forschung und nichtkommerzielle Nutzung).

BreezeTTS · CLI · Swift API

speech speak "The quick brown fox jumps over the lazy dog." --engine breeze \
  --instruct "A clear, calm English narrator." --stream -o design.wav

--breeze-model-id: aufklarer/Breeze-TTS-2-MLX-8bit
--breeze-bundle-dir
--breeze-cache-limit-mib: Optionales prozessweites Limit für wiederverwendbaren MLX-Cache in MiB; 0 deaktiviert den Cache.
--breeze-reference-text
--breeze-temperature: 0.9
--breeze-top-k: 50
--breeze-top-p: 1
--breeze-cfg-scale: 4
--breeze-max-frames: 750
--breeze-seed: 42
--first-chunk-frames: 3
--chunk-frames: 25

Native Laufzeit für Apple · PocketTTS

PocketTTS ergänzt speech-swift um native CoreML-Sprachausgabe. Alle Stufen verwenden standardmäßig nur die CPU. Die englische Stimme Alba liefert jeweils 1.920 Samples mit 24 kHz, also 80 ms pro Audioblock.

Verwendung mit Swift und CLI

speech speak "Hello world." --engine pocket --stream \
  --pocket-bundle-dir /path/to/bundle --pocket-seed 42 -o hello.wav
# --pocket-model-id, --pocket-max-frames, --list-speakers

Der Befehl speech ist der Einstiegspunkt für die lokale Sprachverarbeitung.

Mit Homebrew installieren

Installiere die CLI auf einem Mac mit Apple Silicon und macOS 15 oder neuer über Homebrew:

brew install speech
speech --help

Um eine vorhandene Installation zu aktualisieren, führe brew upgrade speech aus.

Alternative: aus dem Quellcode bauen

Führe in einer lokalen Kopie von speech-swift den Befehl make build aus und verwende anschließend .build/release/speech. Voraussetzungen und Bauanleitung findest du in der Einstiegsanleitung.

transcribe

Transkribiere Audiodateien zu Text.

speech transcribe <file> [options]

Option	Standard	Beschreibung
`<file>`		Zu transkribierende Audiodatei (WAV, M4A, MP3, CAF)
`--engine`	`qwen3`	ASR-Engine: `qwen3`, `qwen3-coreml`, `parakeet`, `nemotron`, `omnilingual`, `cohere`, `voxtral`, `moss`, `whisper`
`--model, -m`	`0.6B`	Modellvariante: `0.6B`, `1.7B` oder vollständige HuggingFace-Modell-ID (nur qwen3) `[whisper]`: `default`, `turbo`, or full CoreML HuggingFace repo ID. `[cohere/voxtral]`: INT5 (Standard), INT8, FP16, eine Hugging-Face-Modell-ID oder ein lokales Verzeichnis. `[moss coreml]`: `int8` (Standard) oder `fp16`; `[moss mlx]`: `int5` (Standard) oder `int8`. Auch eine kompatible Hugging-Face-Repository-ID oder ein lokales Verzeichnis wird akzeptiert.
`--max-tokens`	CoreML: `512` MLX: `5120`	`[moss]` Maximale Anzahl erzeugter Transkript-Tokens.
`--kv-cache`	`fp16`	`[moss mlx]` Präzision des dynamischen KV-Caches: `fp16` oder `int8`.
`--language`		Sprachhinweis (optional, wird von omnilingual ignoriert)
`--window`	`10`	`[omnilingual]` CoreML-Fenstergröße in Sekunden: `5` oder `10`
`--backend`	`coreml`	`[omnilingual]` Backend: `coreml` (Neural Engine) oder `mlx` (Metal-GPU) `[moss]` CoreML nutzt einen festen 1.024-Token-Zustand; MLX bietet einen dynamischen Kontext mit 131.072 Tokens.
`--variant`	`300M`	`[omnilingual mlx]` Größe: `300M`, `1B`, `3B` oder `7B`
`--bits`	`4`	`[omnilingual mlx]` Quantisierungs-Bits: `4` oder `8`
`--stream`		Streaming-Transkription mit VAD aktivieren
`--max-segment`	`10`	Maximale Segmentdauer in Sekunden (Streaming)
`--partial`		Teilergebnisse während der Spracheingabe ausgeben (Streaming)

Beispiele:

# Basic transcription
speech transcribe recording.wav

# Use larger model
speech transcribe recording.wav --model 1.7B

# CoreML encoder (Neural Engine + MLX decoder)
speech transcribe recording.wav --engine qwen3-coreml

# Use Parakeet (CoreML) engine
speech transcribe recording.wav --engine parakeet

# Use Nemotron Streaming (CoreML, English with native punctuation)
speech transcribe recording.wav --engine nemotron                                 # batch
speech transcribe recording.wav --engine nemotron --stream --partial              # streaming

# Omnilingual (CoreML, 1,672 languages)
speech transcribe recording.wav --engine omnilingual                              # 10 s window
speech transcribe recording.wav --engine omnilingual --window 5                     # 5 s window

# Omnilingual (MLX, any length up to 40 s)
speech transcribe recording.wav --engine omnilingual --backend mlx                              # 300M @ 4-bit
speech transcribe recording.wav --engine omnilingual --backend mlx --variant 1B                  # 1B @ 4-bit
speech transcribe recording.wav --engine omnilingual --backend mlx --variant 3B --bits 8         # 3B @ 8-bit
speech transcribe recording.wav --engine omnilingual --backend mlx --variant 7B                  # 7B @ 4-bit

# Cohere Transcribe 2B (MLX, standardmäßig INT5)
speech transcribe recording.wav --engine cohere
speech transcribe recording.wav --engine cohere --model int8 --language de

# Voxtral Mini 3B (MLX, standardmäßig INT5)
speech transcribe recording.wav --engine voxtral
speech transcribe recording.wav --engine voxtral --model int8 --language fr

# MOSS Transcribe Diarize (CoreML, Kurzform)
speech transcribe recording.wav --engine moss
speech transcribe recording.wav --engine moss --model fp16

# MOSS Transcribe Diarize (MLX, 128K Offline-Kontext; INT5 als Standard)
speech transcribe meeting.wav --engine moss --backend mlx
speech transcribe meeting.wav --engine moss --backend mlx --model int8 --kv-cache int8

# Whisper Large-v3 Turbo (CoreML)
speech transcribe recording.wav --engine whisper
speech transcribe recording.wav --engine whisper --model turbo --language de

# Streaming with VAD
speech transcribe recording.wav --stream --partial

align

Wortgenaues Forced Alignment — erhalte präzise Zeitstempel für jedes Wort.

speech align <file> [options]

Option	Standard	Beschreibung
`<file>`		Audiodatei
`--text, -t`		Zu alignierender Text (wenn nicht angegeben, wird zuerst transkribiert)
`--model, -m`	`0.6B`	ASR-Modell zur Transkription: `0.6B`, `1.7B` oder vollständige ID
`--aligner-model`		Modell-ID des Forced Aligners
`--language`		Sprachhinweis

Beispiele:

# Auto-transcribe then align
speech align recording.wav

# Align with known text
speech align recording.wav --text "Can you guarantee that the replacement part will be shipped tomorrow?"

speak

Text-zu-Sprache-Synthese.

speech speak "<text>" [options]

Option	Standard	Beschreibung
`<text>`		Zu synthetisierender Text (optional bei Verwendung von `--batch-file`)
`--engine`	`qwen3`	TTS-Engine: `qwen3`, `cosyvoice`, `voxcpm2`, `indextts2`, `f5`, `higgs`, `breeze`, `indic-mio`, `magpie` oder `magpie-coreml`, `moss-nano`, `fireredtts3`, `moss-voicegenerator`
`--output, -o`	`output.wav`	Pfad der ausgegebenen WAV-Datei
`--language`	`english`	Sprache. Weglassen, um den nativen Dialekt des Sprechers zu verwenden, wenn `--speaker` gesetzt ist.
`--stream`		Streaming-Synthese aktivieren
`--voice-sample`		Referenzaudio für Stimmklonen (funktioniert mit `qwen3`, `cosyvoice`, `voxcpm2`, `f5`, `higgs` und `indextts2`)
`--verbose`		Detaillierte Zeitinformationen anzeigen

Qwen3-TTS-Optionen

Option	Standard	Beschreibung
`--model`	`base`	Modellvariante: `base`, `customVoice` oder vollständige HF-Modell-ID
`--speaker`		Sprecher-Stimme (erfordert `--model customVoice`)
`--instruct`		Stilanweisung (CustomVoice-Modell)
`--list-speakers`		Verfügbare Sprecher auflisten und beenden
`--temperature`	`0.3`	Sampling-Temperatur
`--top-k`	`50`	Top-k-Sampling
`--max-tokens`	`500`	Maximale Tokens (500 = ~40 s Audio)
`--batch-file`		Datei mit einem Text pro Zeile für Batch-Synthese
`--batch-size`	`4`	Maximale Batch-Größe für parallele Generierung
`--first-chunk-frames`	`3`	Codec-Frames im ersten gestreamten Chunk
`--chunk-frames`	`25`	Codec-Frames pro gestreamtem Chunk

CosyVoice3-Optionen

Option	Standard	Beschreibung
`--speakers`		Sprecher-Mapping für Mehrsprecher-Dialog: `s1=alice.wav,s2=bob.wav`
`--cosy-instruct`		Stilanweisung (überschreibt Standard). Steuert den Stimm-Stil für CosyVoice3.
`--turn-gap`	`0.2`	Pause zwischen Dialog-Turns in Sekunden
`--crossfade`	`0.0`	Crossfade-Überlappung zwischen Turns in Sekunden
`--model-id`		HuggingFace-Modell-ID

IndexTTS2-Optionen

IndexTTS2 ist eine Zero-Shot-Stimmklon-Engine mit erweitertem MLX-Bundle. Sie benötigt --voice-sample und läuft derzeit nur als Batch-Synthese.

Option	Standard	Beschreibung
`--indextts2-model-id`	`aufklarer/IndexTTS2-MLX-fp16`	HuggingFace-Modell-ID. Standard ist `aufklarer/IndexTTS2-MLX-fp16`.
`--indextts2-bundle-dir`		Lädt ein lokales erweitertes Bundle statt von Hugging Face herunterzuladen.
`--indextts2-emotion-audio`		Optionales Referenzaudio für Emotion/Stil. Standard ist die Sprecherreferenz.
`--indextts2-emotion`		Optionales Preset oder 8-Werte-Emotionsvektor. Presets enthalten `eager`, `happy`, `excited` und `calm`.
`--indextts2-emotion-weight`	`1.0`	Skaliert `--indextts2-emotion`; moderat halten, wenn Sprecheridentität wichtig ist.
`--indextts2-speaking-rate`	`1.0`	Sprechgeschwindigkeitsfaktor von `0.5` bis `1.5`; Werte über `1.0` sind schneller.
`--indextts2-max-pause`		Optionales Limit für lange interne leise Pausen in Sekunden.
`--indextts2-s2mel-steps`	`15`	S2Mel-Flow-Schritte (Standard 15, hörvalidiert; 25 entspricht exakt dem Upstream)

F5-TTS Options

Option	Standard	Beschreibung
`--f5-reference-text`		Referenztranskript: der Textinhalt von --voice-sample (erforderlich)
`--f5-steps`	`16`	Flow-Matching-Schritte (Standard 16; 32 für maximale Treue)
`--f5-cfg-strength`	`2.0`	Stärke der Classifier-Free Guidance
`--f5-sway`	`-1.0`	Sway-Sampling-Koeffizient
`--f5-speed`	`1.0`	Sprechtempo-Faktor
`--f5-seed`	`0`	Seed für deterministische Ausgabe
`--f5-target-rms`	`0.1`	RMS-Normalisierungsziel der Referenz
`--f5-model-id`		Hugging-Face-Modell-ID
`--f5-bundle-dir`		Bundle aus diesem lokalen Verzeichnis laden

Higgs TTS 3 Options

Option	Standard	Beschreibung
`--higgs-ref-text`		Referenztranskript: der Textinhalt von --voice-sample (verbessert das Cloning)
`--higgs-temperature`	`0.8`	Sampling-Temperatur (Standard 0.8)
`--higgs-top-p`		Nucleus-Sampling-Schwelle (standardmäßig aus)
`--higgs-top-k`		Top-k-Sampling-Grenze (standardmäßig aus)
`--higgs-max-new-tokens`	`2048`	Maximal erzeugte Audioframes (25 pro Sekunde)
`--higgs-seed`	`0`	Seed für deterministische Ausgabe
`--higgs-model-id`		Hugging-Face-Modell-ID
`--higgs-bundle-dir`		Bundle aus diesem lokalen Verzeichnis laden

Beispiele:

# Basic TTS
speech speak "Hello, world!" --output hello.wav

# Voice cloning (Qwen3-TTS)
speech speak "Hello in your voice" --voice-sample reference.wav -o cloned.wav

# Voice cloning (CosyVoice)
speech speak "Hello in your voice" --engine cosyvoice --voice-sample reference.wav -o cloned.wav

# Voice cloning (IndexTTS2)
speech speak "Hello in your voice" --engine indextts2 \
    --voice-sample reference.wav --indextts2-speaking-rate 1.35 \
    --indextts2-max-pause 0.05 -o indextts2.wav

# CosyVoice multilingual
speech speak "Hallo Welt" --engine cosyvoice --language german -o hallo.wav

# Multi-speaker dialogue
speech speak "[S1] Hello there! [S2] Hey, how are you?" \
    --engine cosyvoice --speakers s1=alice.wav,s2=bob.wav -o dialogue.wav

# Inline emotion/style tags
speech speak "(excited) Wow, amazing! (sad) But I have to go..." \
    --engine cosyvoice -o emotion.wav

# Combined: dialogue + emotions + voice cloning
speech speak "[S1] (happy) Great news! [S2] (surprised) Really?" \
    --engine cosyvoice --speakers s1=alice.wav,s2=bob.wav -o combined.wav

# Custom style instruction
speech speak "Hello world" --engine cosyvoice --cosy-instruct "Speak cheerfully" -o cheerful.wav

# Streaming synthesis
speech speak "Long text here..." --stream

# Batch synthesis from file
speech speak --batch-file texts.txt --batch-size 4

Optionen für anweisungsgesteuertes TTS

Experimentell: Die native SDK-Unterstützung aus dem main-Quellcode bauen. Homebrew und andere vorgefertigte CLI-Versionen enthalten diese Engines möglicherweise noch nicht.

Implementierung (PR #541): main

Veröffentlichte MLX-Bundles: aufklarer/FireRedTTS3-Instruct-MLX-fp32 · aufklarer/MOSS-VoiceGenerator-MLX-bf16

Ein Textargument, --instruct und genau ein Bundle-Verzeichnis oder eine kompatible Modell-ID sind erforderlich. Referenzaudio, feste Sprecher und Batch-Eingaben werden nicht unterstützt.

Text und Anweisung sind jeweils auf 32.768 UTF-8-Bytes begrenzt. Der vollständig gerenderte Eingabeprompt einschließlich Vorlage darf 4.096 Tokens nicht überschreiten. Eingaben oberhalb einer dieser Grenzen werden abgewiesen.

FireRedTTS3-Instruct behält Float32-Modell- und Decodergewichte. Audio wird vollständig gepuffert zurückgegeben: --stream weglassen. --language akzeptiert englische und chinesische Aliase. Ein Generierungslimit führt zu einem Fehler statt zu abgeschnittenem Erfolg.

MOSS-VoiceGenerator behält BF16-Sprachgewichte und den FP32-Synthesecodec. --stream liefert inkrementelles PCM. --language weglassen und Sprachanforderungen in --instruct setzen. Vor Abschluss werden alle sechzehn Codebücher geleert.

Die Anweisungsbefolgung ist unbewertet. Kurztextmessungen beschreiben den getesteten Aufbau; die Latenz-Regressionsprüfung bestehender Modelle bleibt ohne eindeutiges Ergebnis.

Option	Standard	Beschreibung
`--fireredtts3-bundle-dir`	—	Kompatibles lokal exportiertes Bundle; entweder dieses oder eine Modell-ID wählen.
`--fireredtts3-model-id`	—	Veröffentlichte kompatible MLX-Bundle-ID; diese oder ein lokales Verzeichnis wählen.
`--fireredtts3-flow-steps`	10	Flow-Schritte je akustischem Patch.
`--fireredtts3-max-patches`	400	Generierungsgrenze; vorzeitig erreicht führt sie zu einem Fehler.
`--moss-voicegenerator-bundle-dir`	—	Kompatibles lokal exportiertes Bundle; entweder dieses oder eine Modell-ID wählen.
`--moss-voicegenerator-model-id`	—	Veröffentlichte kompatible MLX-Bundle-ID; diese oder ein lokales Verzeichnis wählen.
`--moss-voicegenerator-max-frames`	750	Generierungsgrenze; vorzeitig erreicht führt sie zu einem Fehler.
`--moss-voicegenerator-chunk-frames`	3	Vollständige Codec-Frames je PCM-Chunk (1–32).
`--seed`	2 / 42	Request-Seed: FireRedTTS3 standardmäßig 2, MOSS-VoiceGenerator 42.

FireRedTTS3-Instruct · MOSS-VoiceGenerator

kokoro

Leichtgewichtige Text-zu-Sprache-Synthese mit Kokoro-82M auf der Neural Engine (CoreML). Nicht-autoregressiv — ein einziger Forward-Pass, ~45 ms Latenz.

speech kokoro "<text>" [options]

Option	Standard	Beschreibung
`<text>`		Zu synthetisierender Text
`--voice`	`af_heart`	Stimmvoreinstellung (50 verfügbar in 10 Sprachen)
`--language`	`en`	Sprachcode: en, es, fr, hi, it, ja, pt, zh, ko, de
`--output, -o`	`kokoro_output.wav`	Pfad der ausgegebenen WAV-Datei
`--list-voices`		Alle verfügbaren Stimmen auflisten und beenden
`--model, -m`		HuggingFace-Modell-ID

Beispiele:

# Basic Kokoro TTS
speech kokoro "Hello, world!" --voice af_heart -o hello.wav

# French voice
speech kokoro "Bonjour le monde" --voice ff_siwis --language fr -o bonjour.wav

# List all 50 voices
speech kokoro --list-voices

respond

Vollduplex-Sprache-zu-Sprache-Dialog mit PersonaPlex 7B.

speech respond [options]

Option	Standard	Beschreibung
`--input, -i`		Eingabe-WAV-Datei (24 kHz Mono) (erforderlich)
`--output, -o`	`response.wav`	Ausgabe-WAV-Datei der Antwort
`--voice`	`NATM0`	Stimmvoreinstellung (z. B. NATM0, NATF1, VARF0)
`--system-prompt`	`assistant`	Voreinstellung: `assistant`, `focused`, `customer-service`, `teacher`
`--system-prompt-text`		Eigener System-Prompt-Text (überschreibt Voreinstellung)
`--max-steps`	`200`	Maximale Generierungsschritte bei 12,5 Hz (~16 s)
`--stream`		Audio-Chunks während der Generierung ausgeben
`--compile`		Kompilierten Transformer aktivieren (Warmup + Kernel-Fusion)
`--list-voices`		Verfügbare Stimmvoreinstellungen auflisten
`--list-prompts`		Verfügbare System-Prompt-Voreinstellungen auflisten
`--transcript`		Inneren Monolog des Modells als Text ausgeben
`--json`		Ausgabe als JSON (Transkript, Latenz, Audio-Pfad)
`--verbose`		Detaillierte Zeitinformationen anzeigen

Sampling-Überschreibungen

Option	Standard	Beschreibung
`--audio-temp`	`0.8`	Audio-Sampling-Temperatur
`--text-temp`	`0.7`	Text-Sampling-Temperatur
`--audio-top-k`	`250`	Audio-Top-k-Kandidaten
`--repetition-penalty`	`1.2`	Audio-Wiederholungspenalty (1.0 = deaktiviert)
`--text-repetition-penalty`	`1.2`	Text-Wiederholungspenalty (1.0 = deaktiviert)
`--repetition-window`	`30`	Wiederholungspenalty-Fenster in Frames
`--silence-early-stop`	`15`	Stille-Frames vor frühem Abbruch (0 = deaktiviert)
`--entropy-threshold`	`0`	Text-Entropie-Schwelle für frühen Abbruch (0 = deaktiviert)
`--entropy-window`	`10`	Aufeinanderfolgende Schritte mit niedriger Entropie vor frühem Abbruch

Beispiele:

# Basic speech-to-speech
speech respond --input question.wav

# Use a female voice with compiled transformer
speech respond -i question.wav --voice NATF1 --compile

# Stream response and show transcript
speech respond -i question.wav --stream --transcript --verbose

voice-chat

Live-Vollduplexgespräch mit Soniqo auf Basis von NVIDIA Nemotron VoiceChat 11B. Das voreingestellte protected-head INT5-Bundle wird beim ersten Start geladen; der Mikrofonmodus bietet Apple AEC, gestreamte RNN-T-Untertitel, verständliche Echtzeitmetriken, adaptive 8→2→1-Schritt-Sprachverfeinerung und begrenzte Eingabe-Neusynchronisierung statt langer stiller Aufholphasen.

speech voice-chat [options]

Option	Standard	Beschreibung
`--model, -m`	`aufklarer/VoiceChat-11B-Perception-MLX-int5`	Hugging-Face-Modell-ID oder vollständiges lokales Bundle.
`--revision`	`main`	Hub-Revision.
`--system-prompt`		System-Prompt überschreiben.
`--mcp-config`		Anbieterneutrale JSON-Konfiguration für MCP-Werkzeugserver.
`--mcp-server`	alle konfigurierten	Einen Server auswählen; wiederholbar.
`--mcp-write-policy`	`allow`	Schreibregel: sofortiges `allow`, modellvermitteltes `confirm` oder `deny`.
`--mcp-timeout-seconds`	`15`	Timeout für MCP-Werkzeugaufrufe; der Serverstart erhält mindestens 60 Sekunden.
`--greet`		Modell zuerst grüßen lassen.
`--no-aec`		Apple-AEC deaktivieren.
`--no-transcript`		Live-RNN-T-Nutzeruntertitel deaktivieren.
`--no-rnnt-turn-taking`		NVIDIAs RNN-T-Sicherheitsfallbacks für Turn-Taking deaktivieren.
`--prebuffer-frames`	`3`	Vor Wiedergabe gepufferte 80-ms-Ausgabeframes.
`--max-buffered-frames`	`8`	Maximale Zahl wartender 80-ms-Mikrofonframes vor dem Verwerfen alten Audios.
`--max-seconds`		Live-Aufnahme nach dieser Sekundenzahl stoppen.
`--input`		Audiodatei statt Mikrofon lesen.
`--output, -o`		Vollständige 22,05-kHz-WAV schreiben.
`--tail-seconds`	`6`	Stille nach der Dateieingabe.
`--force-turn-at-end`		BOS am Dateiende erzwingen; nur Regression.
`--plain`		Fortlaufende Ausgabe statt des fest neu gezeichneten Dashboards verwenden.
`--debug-timeline`		Relative Zeitstempel für Äußerungen und das Ende der erzeugten Aussprache sowie vom Modell dekodierte Lebenszyklusereignisse von Tool-Aufrufen anzeigen.
`--terminal-width`	`120`	Breite der Terminalanzeige.
`--temperature`	`0`	Texttemperatur; 0 ist greedy.
`--text-top-p`	`1`	Text-top-p.
`--guidance`	`0.2`	EAR-TTS-Guidance-Stärke.
`--speech-top-p`	`0.95`	EAR-TTS-top-p.
`--speech-noise`	`0.001`	EAR-TTS-Sampling-Rauschen.
`--speech-iterations`	`8`	EAR-TTS-MaskGIT-Iterationen pro Frame.
`--realtime-speech-iterations`	`2`	Vorübergehende Sprachverfeinerung zum Schutz der Echtzeitgeschwindigkeit.
`--live-speech-context-seconds`	`20`	Im Live-Modus beibehaltene aktuelle EAR-TTS-Historie; 0 behält den gesamten Verlauf.

Beispiele:

speech voice-chat

speech voice-chat --model /path/to/complete-bundle --prebuffer-frames 3

speech voice-chat --input question.wav --output response.wav

speech voice-chat --mcp-config Examples/VoiceChatMCP/apple-reminders.json

Der Dateimodus ist der reproduzierbare Pfad ohne Audiohardware. --force-turn-at-end ist nur für kontrollierte Regressionstests gedacht und darf nicht als natürliche Sprecherwechsel-Latenz angegeben werden.

Die Apple-Reminders-Demo stellt nur list_reminders, create_reminder und update_reminder bereit; die Listenermittlung bleibt im Adapter. Ein flacher Leseaufruf deckt alle Listen ab, und Aktualisierungen lösen den gesprochenen Namen intern in eine private ID auf. Das Dashboard zeigt Zeit, Token-Schritte und Token/s der Funktionsdekodierung getrennt vom Audio-RTF.

vad

Offline-Sprachaktivitätserkennung mit Pyannote-Segmentierung.

speech vad <file> [options]

Option	Beschreibung
`<file>`	Zu analysierende Audiodatei
`--model, -m`	HuggingFace-Modell-ID
`--onset`	Onset-Schwelle (Sprachbeginn)
`--offset`	Offset-Schwelle (Sprachende)
`--min-speech`	Minimale Sprachdauer in Sekunden
`--min-silence`	Minimale Stille-Dauer in Sekunden
`--json`	Ausgabe als JSON

vad-stream

Streaming-Sprachaktivitätserkennung mit Silero VAD v5. Verarbeitet Audio in 32-ms-Chunks.

speech vad-stream <file> [options]

Option	Beschreibung
`<file>`	Zu analysierende Audiodatei
`--engine`	VAD-Engine: `mlx` (Standard) oder `coreml`
`--model, -m`	HuggingFace-Modell-ID (automatisch je nach Engine)
`--onset`	Onset-Schwelle
`--offset`	Offset-Schwelle
`--min-speech`	Minimale Sprachdauer in Sekunden
`--min-silence`	Minimale Stille-Dauer in Sekunden
`--json`	Ausgabe als JSON
`--smart-turn`	Bestätigt jede Pause mit Smart Turn, bevor ein Segment endet; Pausen mitten im Satz werden zu einem Segment zusammengefasst
`--turn-threshold`	Smart-Turn-Abschlussschwelle (Standard `0.5`)
`--turn-max-silence`	Sekunden Stille nach einer abgelehnten Pause, nach denen das Segment trotzdem endet (Standard `2.0`)

turn

Turn-Ende-Erkennung mit Smart Turn v3.2 (8M Parameter, CoreML, 23 Sprachen). Bewertet die letzten 8 s einer aufgezeichneten Äußerung und gibt die Wahrscheinlichkeit, dass die Person zu Ende gesprochen hat, das Urteil abgeschlossen / nicht abgeschlossen und die Inferenzzeit aus.

speech turn <file> [options]

Option	Beschreibung
`<file>`	Audiodatei mit einem Nutzer-Turn (beliebige Abtastrate); verwendet werden die letzten 8 s
`--threshold`	Wahrscheinlichkeit, ab der der Turn als abgeschlossen gilt (Standard `0.5`)
`--model, -m`	HuggingFace-Modell-ID. Standard `aufklarer/Smart-Turn-v3.2-CoreML`
`--model-dir`	Lokales Verzeichnis mit `smart_turn.mlmodelc` und `config.json`; überspringt den Download
`--json`	Ausgabe als JSON

# Probability, verdict and inference time for one utterance
speech turn utterance.wav

# Custom threshold, JSON output
speech turn utterance.wav --threshold 0.7 --json

# Streaming VAD with Smart Turn confirming each pause
speech vad-stream call.wav --smart-turn --turn-threshold 0.6 --turn-max-silence 1.5

wake

Schlüsselworterkennung auf dem Gerät mit dem KWS Zipformer (3,49 Mio. Parameter, CoreML INT8, 26× Echtzeit, nur Englisch).

speech wake <file> [options]

Option	Beschreibung
`<file>`	Zu analysierende Audiodatei
`--keywords`	Ein oder mehrere Schlüsselwörter. Formate: `"hey soniqo"`, `"hey soniqo:0.15:0.5"` oder `"LIGHT UP\|▁ L IGHT ▁UP:0.25:2.0"` (sherpa-onnx-Stil mit expliziten BPE-Stücken)
`--keywords-file`	Schlüsselwortdatei, ein Eintrag pro Zeile
`--model, -m`	HuggingFace-Modell-ID. Standard: `aufklarer/KWS-Zipformer-3M-CoreML-INT8`
`--json`	Ausgabe als JSON

diarize

Sprecherdiarisierung — identifiziert, wer wann gesprochen hat.

speech diarize <file> [options]

Option	Standard	Beschreibung
`<file>`		Zu analysierende Audiodatei
`--engine`	`pyannote`	Diarisierungs-Engine: `pyannote`, `community1` (CoreML + natives PLDA/VBx) oder `sortformer`
`--community1-compute-units`	`ane`	Community-1 CoreML-Recheneinheiten: `ane`, `cpu`, `gpu` oder `all`
`--num-speakers`		Bekannte genaue Sprecherzahl für Community-1
`--min-speakers`	`1`	Minimale Sprecherzahl für Community-1
`--max-speakers`		Maximale Sprecherzahl für Community-1
`--target-speaker`		Enrollment-Audio zur Zielsprecher-Extraktion (nur pyannote)
`--embedding-engine`	`mlx`	Sprechereinbettungs-Engine: `mlx` oder `coreml` (nur pyannote)
`--vad-filter`		Mit Silero VAD vorfiltern (nur pyannote)
`--rttm`		Ausgabe im RTTM-Format
`--json`		Ausgabe als JSON
`--score-against`		RTTM-Referenzdatei zur DER-Berechnung

Beispiele:

# Basic diarization (pyannote, default)
speech diarize meeting.wav

# End-to-end Sortformer (CoreML, Neural Engine)
speech diarize meeting.wav --engine sortformer

# RTTM output for evaluation
speech diarize meeting.wav --rttm

# Target speaker extraction (pyannote only)
speech diarize meeting.wav --target-speaker enrollment.wav

# Score against reference
speech diarize meeting.wav --score-against reference.rttm

embed-speaker

Extrahiert einen Sprechereinbettungs-Vektor aus Audio.

speech embed-speaker <file> [options]

Option	Beschreibung
`<file>`	Audiodatei mit der Stimme des Sprechers
`--engine`	`mlx` (Standard) oder `coreml` für WeSpeaker 256-dim; `redimnet2` für persistente Identität CoreML 192-dim; `camplusplus` für CAM++ CoreML 192-dim
`--json`	Ausgabe als JSON

language-id

Erkennt die gesprochene Sprache in einer Audiodatei.

speech language-id <file> [options]

Option	Beschreibung
`<file>`	Zu klassifizierende Audiodatei
`--engine`	Inferenz-Engine: mlx oder coreml
`--model`	Hugging-Face-Modell-ID überschreiben
`--top`	Anzahl der Sprachkandidaten
`--json`	Ergebnis als JSON ausgeben

speech language-id recording.wav --top 5
speech language-id recording.wav --engine coreml --json

denoise

Entfernt Hintergrundgeräusche mit DeepFilterNet3 auf der Neural Engine.

speech denoise <file> [options]

Option	Standard	Beschreibung
`<file>`		Eingabe-Audiodatei
`--output, -o`	`input_clean.wav`	Ausgabe-Dateipfad
`--model, -m`		HuggingFace-Modell-ID

Beispiel:

speech denoise noisy-recording.wav -o clean.wav

compose

Generate 30 s of music from a text prompt using MAGNeT on MLX.

speech compose <prompt> [options]

Option	Default	Description
`<prompt>`		Text prompt describing the music to generate (e.g. "happy rock")
`--output, -o`	`magnet.wav`	Output WAV path (32 kHz mono)
`--variant`	`small-int4`	Model variant: `small-int4`, `small-int8`, `medium-int4`, or `medium-int8`. Resolves to `aufklarer/MAGNeT-{Small,Medium}-30secs-MLX-{4,8}bit`.
`--temperature`	`3.0`	Sampling temperature, annealed linearly per stage.
`--top-p`	`0.9`	Nucleus sampling threshold.
`--cfg-max`	`10.0`	Max classifier-free guidance coefficient.
`--cfg-min`	`1.0`	Min CFG coefficient (annealed alongside the mask schedule).
`--steps`	`20,10,10,10`	Comma-separated decoding iterations per codebook (4 values).
`--seed`		Random seed for reproducible output.

Examples:

# Default: small-int4, ~10 s wall on M-series for a 30 s clip
speech compose "happy rock" -o happy_rock.wav

# Larger model — better prompt following, slower
speech compose "lo-fi hip hop with mellow piano" --variant medium-int4 -o lofi.wav

# Reproducible
speech compose "energetic EDM with synth lead" --seed 42 -o edm.wav

transcribe-batch

Transkribiert ein Verzeichnis von Audiodateien; das Modell wird nur einmal geladen.

speech transcribe-batch <input-dir> [options]

Option	Standard	Beschreibung
`<input-dir>`		Verzeichnis der zu transkribierenden Audiodateien (WAV, FLAC usw.)
`--output-dir`		Ausgabeverzeichnis für die Transkripte
`--engine`	`qwen3`	ASR-Engine (gleiche Werte wie transcribe)
`--jsonl`		Ausgabe als JSON Lines, eine pro Datei

restore

Sprachwiederherstellung (Entrauschen + Enthallen) mit Sidon — CoreML, 48-kHz-Ausgabe.

speech restore <audio-file> [options]

Option	Standard	Beschreibung
`--output, -o`	`input_restored.wav`	Pfad der WAV-Ausgabedatei (48 kHz)
`--variant`	`fp16`	Präzisions- / Bundle-Variante
`--compute-units`		Core ML-Platzierung für beide Stufen: ane, gpu, cpu, all (Standard: Vocoder gpu, Predictor automatisch)

separate

Trennt einen Musiktitel in Stems (vocals, drums, bass, other).

speech separate <input> [options]

Option	Standard	Beschreibung
`--stems`	`vocals,drums,bass,other`	Zu extrahierende Stems: vocals, drums, bass, other
`--engine`	`umx`	Engine: umx (Standard) oder htdemucs (höhere Qualität)
`--output-dir`		Ausgabeverzeichnis für die Transkripte

upsample

Audio-Superresolution mit FlashSR — einstufig destilliertes AudioSR, 48-kHz-Ausgabe.

speech upsample <audio-file> [options]

Option	Standard	Beschreibung
`--output, -o`	`hr.wav`	Pfad der WAV-Ausgabedatei (48 kHz)
`--variant`	`int4`	Präzisions- / Bundle-Variante
`--seed`		Seed für deterministische Ausgabe

qwen3-tts-coreml

Swift unterstützt 0.6B/256- und 1.7B/1024-Bundles; 0.6B bleibt der Standard. Das experimentelle 1.7B-Bundle verwendet standardmäßig die CPU und benötigt über --speaker-embedding ein vorbereitetes Float32-Sprecher-Embedding im Format .npy mit 2048 Kanälen. GPU/ANE und iOS müssen separat validiert werden.

speech qwen3-tts-coreml "<text>" [options]

Option	Standard	Beschreibung
`--output, -o`	`output.wav`	Pfad der WAV-Ausgabedatei
`--language`	`english`	Ausgabesprache
`--model`		Hugging-Face-Modell-ID
`--model-directory`	—	Lokales kompiliertes Modell-Bundle; hat Vorrang vor dem Download von `--model`.
`--speaker-embedding`	—	Vorbereitetes Float32-Sprecher-Embedding im Format `.npy` mit passender Modellbreite (1024 oder 2048).

vibevoice

Text-zu-Sprache mit Microsoft VibeVoice (MLX).

speech vibevoice "<text>" --voice-cache <cache> [options]

Option	Standard	Beschreibung
`--voice-cache, -v`		Voice-Cache aus vibevoice-encode-voice (erforderlich)
`--steps`		DPM-Solver-Inferenzschritte (mehr Schritte, bessere Qualität)
`--cfg`	`1.3`	Stärke der Classifier-Free Guidance
`--long-form`		Langform-Synthese in Abschnitten für lange Texte

vibevoice-encode-voice

Erzeugt einen VibeVoice-Voice-Cache aus Referenzaufnahme plus Transkript.

speech vibevoice-encode-voice <input> "<transcript>" [options]

Option	Standard	Beschreibung
`<input>`		Referenz-Audiodatei
`<transcript>`		Transkript des Referenzaudios (nur Englisch)
`--output, -o`		Ausgegebener Voice-Cache (.safetensors)

translate

Übersetzt Text mit MADLAD-400 in eine Zielsprache (MLX).

speech translate "<text>" --to <lang> [options]

Option	Standard	Beschreibung
`--to, -t`		Zielsprachcode (ISO 639-1, z. B. es, zh, ja)
`--stream`		Tokens beim Dekodieren streamen
`--model`		Hugging-Face-Modell-ID

⚠ Translation out of date — the Clef CLI section awaits translation. English reference.

clef

Choose from allowed answers using Clef-flash locally on Apple Silicon. Development preview.

speech clef decide request.json
speech clef decide request.json --model-dir /path/to/Clef-flash-9B-MLX-4bit
speech clef decide request.json --offline --max-tokens 4096

The request contains text in state and an ordered questions array. Each field has an id and a type: choice with a choices map, noul for true/false, or score with ordered levels. Output is JSON with probabilities, selected answers, token count, model-load time, and decision time.

By default, the command downloads aufklarer/Clef-flash-9B-MLX-4bit. Use --model-dir for existing files or --offline for the cache. The token limit defaults to 4096 and accepts 1–16384. See the Clef guide for a complete request and measured memory use.

gliner

Textklassifikation nach vorgegebenen Labels und Entitätsextraktion mit GLiNER2.5-Decide (MLX). Entwicklungsvorschau: noch in keinem Release enthalten. Ohne Text wird von stdin gelesen.

speech gliner classify "<text>" --labels <a,b,c> [options]
speech gliner extract "<text>" --labels <a,b,c> [options]

Option	Standard	Beschreibung
`--variant`	int8	Zu ladende veröffentlichte Gewichte: fp32, fp16 oder int8
`--model`		Abweichendes Hugging-Face-Repository
`--model-dir`		Lokales Modellverzeichnis statt Download
`--labels`		Kommagetrennte Kandidaten-Labels (1 bis 255, eindeutig)
`--description`		Label-Beschreibung als label=text; mehrfach angebbar
`--task`	action	Aufgabenname im Schema-Prompt (nur classify)
`--threshold`	0.5	Mindestscore für Spans (nur extract)
`--evaluate-layers`		Encoder-Schichten einzeln auswerten, um den Spitzenspeicher zu senken
`--json`		JSON-Ausgabe mit allen Wahrscheinlichkeiten bzw. Spans mit UTF-16-Offsets und Laufzeiten

avatar-motion

Erzeugt NVIDIA-Audio2Face-3D-Koeffizientenframes für Avatarbewegung aus Sprachaudio.

speech avatar-motion <input> [options]

Option	Standard	Beschreibung
`--output, -o`	`avatar-motion.jsonl`	Pfad der JSONL-Ausgabedatei
`--model`	`…James-MLX`	Avatar-Identitäts-Bundle (Standard James; Claire und Mark verfügbar)
`--verbose`		Timing und Frame-Anzahl ausgeben

MOSS-TTS-Nano

--voice-sample klont eine Stimme ohne Referenztranskript. Mono-Referenzen werden zu Stereo dupliziert, auf 48 kHz resampelt und auf volle 80 ms aufgefüllt. Eine Referenz einmal kodieren und ihre Codes für weitere Anfragen wiederverwenden.

speech speak "Hello world." --engine moss-nano -o hello.wav
speech speak "The weather is nice today." --engine moss-nano \
  --voice-sample reference.wav --moss-nano-seed 1 -o cloned.wav
speech speak "Hello world." --engine moss-nano --stream --play -o streamed.wav

`--moss-nano-model`	aufklarer/MOSS-TTS-Nano-100M-CoreML	Modell-Repository oder lokales Verzeichnis
`--moss-nano-compute-units`	cpu	cpu oder gpu
`--moss-nano-max-frames`	300	Maximale 80-ms-Frames; natürliches Ende erforderlich
`--moss-nano-seed`	0	Reproduzierbarer Swift-Sampling-Seed

MOSS-TTS-Nano

Voxtral TTS

Voxtral 4B TTS 2603 läuft über das Modul VoxtralTTS lokal auf Apple Silicon: 20 voreingestellte Stimmen, neun Sprachen und Mono-Sprache mit 24 kHz.

speech speak "Hello, welcome to Voxtral." --engine voxtral --voxtral-voice casual_male --stream --voxtral-chunk-frames 3 -o hello.wav
speech speak --engine voxtral --list-speakers
speech speak "Bonjour." --engine voxtral --voxtral-voice fr_female --voxtral-max-frames 500 --voxtral-seed 0 -o bonjour.wav

Nur vorgegebene Stimmen; das Klonen anhand von Referenzaudio ist nicht verfügbar. SDK, CLI, WebSocket und HTTP PCM geben Audio während der Erzeugung aus. Der Eingabetext muss zu Beginn vollständig vorliegen. Die Modellgewichte stehen unter CC BY-NC 4.0.

Voxtral-TTS-Anleitung lesen

Fish Audio Drama 3

Experimentelle native MLX-Unterstützung für Drama 3 steht über FishAudioDrama3Model bereit. Ein MoE-Modell mit 35 Milliarden Parametern, hybrider Aufmerksamkeit, zeitlichem Audiodecoder und Fish DAC erzeugt Mono-Audio mit 44,1 kHz. Der 4-Bit-Checkpoint bestand auf Apple M5 Pro die Audio- und unabhängigen ASR-Tests für Spracherzeugung aus Text, Stimmklonen mit Referenz und CLI-Ausgabe. 8-Bit und BF16 sind noch ungeprüft.

Der Speichermodus balanced ist voreingestellt. Ungenutzte MLX-Puffer werden an Phasengrenzen freigegeben, wenn der Cache 512 MiB überschreitet; das ist keine Grenze für den Gesamtspeicher. Globale Speichergrenzen bleiben unverändert. Mit --fish-drama3-memory-mode unrestricted oder memoryOptions: .unrestricted werden alle Gewichte vorab geladen und das bisherige Cache-Verhalten verwendet.

Bei reiner Textsynthese werden 794.4 MiB Referenzencoder-Gewichte erst später geladen. Die erste Referenzkodierung lädt und behält sie; halten Sie codec.safetensors bis dahin verfügbar. Vorab berechnete Referenzcodes benötigen den Encoder nicht.

Übergeben Sie den vollständigen Text. Stimmklonen erfordert eine Referenzaufnahme und deren exaktes Transkript. Sprecher-Tags 0–15 und Emotionsangaben im Text werden unterstützt. PCM-Streaming ist über generateStreaming, generateStream und --stream verfügbar. Ein Chunk enthält standardmäßig 3 Codec-Frames, etwa 139 ms Audio. Automatische Aufteilung langer Texte und schrittweise Texteingabe werden noch nicht unterstützt. Bei Erreichen des Frame-Limits wird ein Fehler ausgelöst.

speech speak "Hello from Drama 3." --engine fish-drama3 --fish-drama3-bundle-dir /path/to/bundle -o hello.wav
speech speak "Hello from Drama 3." --engine fish-drama3 --stream --fish-drama3-chunk-frames 3 -o streamed.wav
speech speak "Hello in the reference voice." --engine fish-drama3 --voice-sample reference.wav --fish-drama3-reference-text "The exact reference transcript." --seed 42 -o cloned.wav

import FishAudioTTS
let model = try await FishAudioDrama3Model.fromBundle(bundleURL, memoryOptions: .balanced)
let pcm = try await model.generate(text: "Hello from Drama 3.", options: .init(seed: 42))

Option	Standardwert
`--fish-drama3-model-id`	`mlx-community/fish-audio-drama-3-4bit`
`--fish-drama3-bundle-dir`	`—`
`--fish-drama3-reference-text`	`—`
`--fish-drama3-max-frames`	`2048`
`--fish-drama3-temperature`	`1`
`--fish-drama3-top-k`	`30`
`--fish-drama3-top-p`	`0.9`
`--voice-sample`	`—`
`--seed`	`0`
`--stream`	`false`
`--fish-drama3-chunk-frames`	`3`
`--fish-drama3-memory-mode`	`balanced`

Mit Fish Audio erstellt. Die Pakete enthalten die Community License und NOTICE.

4-Bit-Messung