MOSS-TTS (nur CPU, 100M)

Führe MOSS-TTS aus — ultraleichtes, CPU-first, mehrsprachiges Text-to-Speech mit 100M Parametern von OpenMOSS (MOSI.AI + Fudan NLP) auf Clore.ai.

MOSS-TTS ist eine Open-Source-Sprachgenerierungsfamilie von OpenMOSS (Shanghai Innovation Institution, in Zusammenarbeit mit Fudan NLP und MOSI.AI, geleitet von Prof. Xipeng Qiu). Das Flaggschiff MOSS-TTS-Nano ist nur 100 Mio. Parameter, läuft in Echtzeit auf einer 4-Kern-CPU ohne GPU, gibt 48-kHz-Stereo, und unterstützt 20 Sprachen mit Zero-Shot-Stimmenklonung. Die gesamte Familie skaliert bis 8B für Mehrsprecher-Dialoge, Voice Design und Soundeffekt-Generierung.

Veröffentlicht: 10. April 2026 (Nano) · ONNX-CPU-Build 17. April 2026 · Lizenz: Apache 2.0

Wenn Kokoro die 82M-Parameter-Western-English-Nische beherrscht, beherrscht MOSS-TTS-Nano die CPU-first Mehrsprachen- Nische: dieselbe Tiny-Model-Philosophie, aber Stereo 48 kHz, 20 Sprachen, Stimmenklonung und ein Torch-freier ONNX/GGUF-Pfad. Für alle, die TTS bereitstellen wollen, ohne für eine GPU zu zahlen — das ist das Modell.

MOSS-TTS-Familie

Modell	Größe	VRAM	Am besten geeignet für
MOSS-TTS-Nano-100M	100M	0 GB (CPU, 4 Kerne)	Echtzeit, Edge, IVR, On-Device
MOSS-TTS-Nano-100M-ONNX	100M	0 GB (CPU)	Torch-fähiger Produktionsbetrieb
MOSS-TTS-GGUF	100M (Q4_K_M)	0 GB (CPU)	Bereitstellungen im Stil von llama.cpp
MOSS-TTS-Local-Transformer	1,7B	4 GB	Leichte GPU, starke objektive Qualität
MOSS-TTS-Realtime	1,7B	4 GB	Mehrstufige Sprachagenten, 180 ms TTFB
MOSS-VoiceGenerator	1,7B	4 GB	Stimmendesign aus Text-Prompts
MOSS-TTSD-v1.0	8B	8 GB	Mehrsprecher-Dialoge, lange Podcasts
MOSS-SoundEffect	8B	8 GB	Soundeffekt-Generierung mit Dauersteuerung

Wichtige Spezifikationen

Spezifikation	Wert
Entwickler	OpenMOSS Team · MOSI.AI · Fudan NLP Lab
Architektur	Autoregressiv (Audio-Tokenizer + LLM)
Abtastrate	48 kHz, Stereo
Sprachen	20 (zh, en, de, es, fr, ja, it, hu, ko, ru, fa, ar, pl, pt, cs, da, sv, el, tr, +1)
Stimmklonung	Zero-Shot aus ~3 s Referenz
Streaming	Ja — Chunked Decoding auf der CPU
Lizenz	Apache 2.0
HuggingFace	OpenMOSS-Team
GitHub	OpenMOSS/MOSS-TTS-Nano · OpenMOSS/MOSS-TTS

Warum MOSS-TTS?

• GPU-freie Bereitstellung — Nano läuft auf 4 CPU-Kernen, ohne CUDA, ohne Triton

• 48-kHz-Stereoausgabe — sendetaugliche Qualität, selten bei Modellen unter 100M

• 20 Sprachen — mehr Sprachabdeckung als Kokoro (~5) bei ähnlicher Größe

• Zero-Shot-Stimmenklonierung aus ~3 s Referenzaudio

• Torch-freie ONNX/GGUF-Pfade — mit einer 200-MB-Binärdatei ausliefern

• Die Familie skaliert nach oben — derselbe Tokenizer/API von Nano bis 8B TTSD

• Apache 2.0 — kommerzielle Nutzung, ohne Auflagen

• Aus seriöser Forschung — Fudan NLP + MOSI.AI, kein Hobbyprojekt

Anforderungen

Komponente	Minimum (Nano, CPU)	Empfohlen (Nano, CPU)	Gesamte Familie (GPU)
CPU	4 Kerne (x86_64 / ARM64)	8 Kerne	8 Kerne
RAM	4 GB	8 GB	16 GB
GPU	— (nicht erforderlich)	— (optional)	RTX 3060 12 GB+
VRAM	0 GB	0 GB	4–8 GB
Festplatte	1 GB	2 GB	10 GB (8B + Abhängigkeiten)
Python	3.12	3.12	3.12

Clore.ai-Tipp: Nano benötigt buchstäblich keine GPU. Wenn du bereits eine Clore-Box für andere Arbeit hast, ist TTS kostenlos. Wenn du möchtest eine GPU für Batch-Durchsatz oder zum Ausführen der 1,7B/8B-Varianten, ist eine RTX 3060 12 GB ($0.03–0.07/Std.) überdimensioniert.

Option A — Python-Installation + schnelle Inferenz

conda create -n moss-tts-nano python=3.12 -y
conda activate moss-tts-nano

git clone https://github.com/OpenMOSS/MOSS-TTS-Nano.git
cd MOSS-TTS-Nano
pip install -r requirements.txt
pip install -e .

# Falls pynini bei pip scheitert, conda-forge verwenden:
conda install -c conda-forge pynini=2.1.6.post1 -y

Inferenz aus dem Referenzaudio + Zieltext:

python infer.py \\
  --prompt-audio-path assets/audio/en_1.wav \\
  --text "Willkommen bei Clore.ai — dem dezentralen GPU-Marktplatz."
# Ausgabe: generated_audio/infer_output.wav  (48-kHz-Stereo)

Oder über den CLI-Einstiegspunkt:

moss-tts-nano generate \\
  --prompt-speech ref.wav \\
  --text "Hallo von MOSS-TTS Nano, das auf der CPU läuft."

Web-Demo (Gradio):

python app.py
# → http://127.0.0.1:18083

Option B — Docker (CPU und GPU)

Nur CPU (Nano, ~1 GB Image):

FROM python:3.12-slim
RUN apt-get update && apt-get install -y git build-essential \\
    && rm -rf /var/lib/apt/lists/*
WORKDIR /app
RUN git clone https://github.com/OpenMOSS/MOSS-TTS-Nano.git . \\
    && pip install -r requirements.txt && pip install -e .
EXPOSE 18083
CMD ["python", "app.py"]

docker build -t moss-tts-nano-cpu .
docker run --rm -p 18083:18083 moss-tts-nano-cpu

GPU-Variante (für Realtime / TTSD / SoundEffect):

docker run --gpus all -p 18083:18083 \\
  pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime \\
  bash -c "git clone https://github.com/OpenMOSS/MOSS-TTS.git /app \\
           && cd /app \\
           && pip install --extra-index-url https://download.pytorch.org/whl/cu128 -e '.[torch-runtime]' \\
           && python app.py"

Option C — Zero-Shot-Stimmenklonung (3 s Referenz)

MOSS-TTS-Nano klont eine Stimme aus einem kurzen Referenzclip und verarbeitet die Generierung langer Formate über automatische Chunking.

from moss_tts_nano import MossTTSNano
import soundfile as sf

model = MossTTSNano.from_pretrained("OpenMOSS-Team/MOSS-TTS-Nano-100M")

# Stimme aus einem beliebigen sauberen 3–10-s-Clip klonen
audio, sr = model.synthesize(
    text="Dies ist meine geklonte Stimme, die ein Clore.ai-Hörbuchkapitel erzählt.",
    prompt_audio_path="speaker_ref_3s.wav",
    language="en",
)
sf.write("cloned.wav", audio, sr)  # 48-kHz-Stereo

Qualitätstipps (übernommen aus dem XTTS-Playbook — dieselben Prinzipien gelten):

• Verwende 3–10 s saubere Referenz (keine Hintergrundmusik, kein Raumhall)

• Wenn möglich, Sprache der Referenz und des Zieltexts angleichen

• Vor dem Einlesen normalisieren und Stille kürzen (librosa.effects.trim)

• Für konsistente Langform-Narration dieselbe Referenz über Aufrufe hinweg wiederverwenden

Option D — GGUF auf llama.cpp-audio / Torch-freies ONNX

Für Edge-Boxen, mobile Backends oder überall dort, wo du PyTorch nicht möchtest:

# Das Haupt-Repo mit den Torch-freien Extras klonen
git clone https://github.com/OpenMOSS/MOSS-TTS.git
cd MOSS-TTS
pip install -e ".[llama-cpp-onnx]"

# GGUF-quantisierte Gewichte abrufen (Q4_K_M)
huggingface-cli download OpenMOSS-Team/MOSS-TTS-GGUF --local-dir weights/

# Oder reiner ONNX-Build (ganz ohne torch)
huggingface-cli download OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX --local-dir weights-onnx/

Dieser Pfad läuft mit llama.cpp-kompatiblen Tools — großartig für Raspberry Pi, Android oder serverlose Funktionen, bei denen eine 200-MB-Binärdatei wichtig ist.

GPU-Empfehlungen für Clore.ai

Nano braucht keine GPU. Das ist ja der ganze Punkt. Aber wenn du Batch-Generierung willst oder die größeren Geschwister ausführen möchtest:

GPU	VRAM	Passt	Clore-Preis (ca.)
Nur-CPU-Instanz	—	Nano, Nano-ONNX, GGUF	ab $0.01/Std.
RTX 3060 12 GB	12 GB	Nano + Local-Transformer + Realtime	ab $0.03–0.07/Std.
RTX 3090 24 GB	24 GB	Vollständiges TTSD-v1.0 (8B), Batch-Serving	ab $0.07–0.21/Std.
RTX 4090 24GB	24 GB	TTSD + SoundEffect gleichzeitig	ab $0.14–0.42/Std.

Für 90 % der produktiven TTS-Workloads — Sprachagenten, IVR, Narration — ist eine reine CPU-Clore.ai-Box buchstäblich die günstigste praktikable Bereitstellung. Miete sie, betreibe MOSS-TTS-Nano, vergiss GPU-Rechnungen.

Anwendungsfälle

• Hörbücher — Langform-Narration mit konsistenter geklonter Stimme, automatisches Chunking

• Sprachagenten — subsekundäre TTFB in der Realtime-Variante für Conversational AI

• IVR / Telefonsysteme — CPU-freie Bereitstellung, 48-kHz-Stereo, 20 Sprachen

• Spiel-NPCs — leicht genug, um in einem Game-Client ausgeliefert zu werden, Voice Design pro Figur

• Synchronisation — mehrsprachige Klonung für Lokalisierungspipelines

• Podcast-Generierung — MOSS-TTSD-v1.0 verarbeitet Mehrsprecher-Dialoge nativ

• Soundeffekte — MOSS-SoundEffect ergänzt die Pipeline um dauergesteuerte FX

Benchmarks / Qualität

• MOSS-TTSD-v1.0 übertraf Doubao und Gemini 2.5-pro bei subjektiven Bewertungen von Mehrsprecher-Dialogen

• Nano liefert einen Real-Time-Faktor < 1,0 auf 4 CPU-Kernen (d. h. schneller als die Wiedergabe)

• Realtime Variante berichtet ~180 ms Zeit bis zum ersten Byte für den conversationalen Einsatz

• Stereo-48-kHz-Ausgabe ist bei diesem Parameterbudget ein deutlicher Fortschritt gegenüber 24-kHz-Mono-Konkurrenten

Fehlerbehebung

Problem	Lösung
pynini Installation schlägt über pip fehl	conda install -c conda-forge pynini=2.1.6.post1 -y dann WeTextProcessing neu installieren
Ruckeliges Audio auf CPU	Stelle 4+ physische Kerne sicher; deaktiviere SMT-/HT-Überbelegung; verwende den ONNX-Build
Geklonte Stimme klingt falsch	Referenz muss 3–10 s lang, sauber, Einzelsprecher und sprachlich passend sein
OOM bei TTSD-v1.0	Verwende FP16 (model.half()) oder wechsle auf den 1,7B Local-Transformer
Modelldownload hängt fest	Setze HF_HUB_ENABLE_HF_TRANSFER=1 und erneut versuchen
Langsamer erster Lauf	Die erste Inferenz kompiliert Kernel / lädt ~400 MB Gewichte herunter — nachfolgende Läufe sind schnell
Torch verursacht Konflikte mit anderen Modellen	Nutzen Sie den [llama-cpp-onnx] Extras für eine Torch-freie Umgebung

Nächste Schritte

• Kokoro TTS — die 82M-Alternative mit Fokus auf Englisch, falls du kein Multilingual brauchst

• Voxtral TTS — 4B Mistral-Modell, 9 Sprachen, GPU erforderlich, aber höheres Potenzial

• XTTS (Coqui) — Stimmenklonung für 17 Sprachen, nur GPU, größer

• Whisper-Transkription — MOSS-TTS mit Whisper für vollständige Sprachpipelines kombinieren

• Miete eine GPU (oder CPU) auf dem Clore.ai-Marktplatz

---

Zuletzt aktualisiert: 20. April 2026