> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/audio-and-sprache/moss-tts.md).

# MOSS-TTS (nur CPU, 100M)

MOSS-TTS ist eine quelloffene Familie zur Sprachgenerierung 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 **100M Parameter**, läuft in Echtzeit auf einer **4-Kern-CPU ohne GPU**, gibt **48-kHz-Stereo**aus und unterstützt **20 Sprachen** mit Zero-Shot-Sprachklonen. Die gesamte Familie skaliert bis zu 8B für Multi-Sprecher-Dialoge, Stimmendesign und Soundeffekt-Generierung.

{% hint style="info" %}
**Veröffentlicht:** 10. April 2026 (Nano) · ONNX-CPU-Build 17. April 2026 · **Lizenz:** Apache 2.0
{% endhint %}

Wenn Kokoro die 82M-Parameter-Western-English-Nische besitzt, besitzt MOSS-TTS-Nano die **CPU-first mehrsprachige** Nische: dieselbe Tiny-Model-Philosophie, aber Stereo mit 48 kHz, 20 Sprachen, Sprachklonen und ein torch-freier ONNX/GGUF-Pfad. Für alle, die TTS bereitstellen wollen, ohne für eine GPU zu bezahlen — 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-freies Produktiv-Serving             |
| **MOSS-TTS-GGUF**              | 100M (Q4\_K\_M) | 0 GB (CPU)          | Bereitstellungen im llama.cpp-Stil         |
| **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                | Multi-Sprecher-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)                                             |
| **Sprachklonen** | Zero-Shot aus \~3s Referenz                                                                                                     |
| **Streaming**    | Ja — stückweise Dekodierung auf der CPU                                                                                         |
| **Lizenz**       | Apache 2.0                                                                                                                      |
| **HuggingFace**  | [OpenMOSS-Team](https://huggingface.co/OpenMOSS-Team)                                                                           |
| **GitHub**       | [OpenMOSS/MOSS-TTS-Nano](https://github.com/OpenMOSS/MOSS-TTS-Nano) · [OpenMOSS/MOSS-TTS](https://github.com/OpenMOSS/MOSS-TTS) |

### Warum MOSS-TTS?

* **Bereitstellung ohne GPU** — Nano läuft auf 4 CPU-Kernen, kein CUDA, kein Triton
* **48-kHz-Stereoausgabe** — Broadcast-Qualität, selten bei Modellen unter 100M
* **20 Sprachen** — mehr Abdeckung als Kokoro (\~5) bei ähnlicher Größe
* **Zero-Shot-Sprachklonen** aus \~3s Referenz-Audio
* **Torch-freie ONNX/GGUF-Pfade** — ausliefern mit einer 200-MB-Binärdatei
* **Familie skaliert nach oben** — derselbe Tokenizer/dieselbe API von Nano bis 8B TTSD
* **Apache 2.0** — kommerzielle Nutzung, ohne Haken
* **Aus ernsthafter 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                        |

{% hint style="success" %}
**Clore.ai-Tipp:** Nano braucht buchstäblich keine GPU. Wenn du bereits eine Clore-Maschine für andere Arbeiten hast, ist TTS gratis. Wenn du *möchtest* eine GPU für Batch-Durchsatz oder um die 1.7B/8B-Varianten zu betreiben, ist eine **RTX 3060 12 GB (\~0,10–0,30 $/Tag)** überdimensioniert.
{% endhint %}

## Option A — Python-Installation + schnelle Inferenz

```bash
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 .

# Wenn pynini bei pip fehlschlägt, verwende conda-forge:
conda install -c conda-forge pynini=2.1.6.post1 -y
```

Inferenz aus dem Referenz-Audio + Zieltext:

```bash
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:

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

Web-Demo (Gradio):

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

## Option B — Docker (CPU und GPU)

**Nur CPU** (Nano, \~1-GB-Image):

```dockerfile
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"]
```

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

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

```bash
docker run --gpus all -p 18083:18083 \
  pytorch/pytorch:2.5.1-cuda12.4-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-Sprachklonen (3s Referenz)

MOSS-TTS-Nano klont eine Stimme aus einem kurzen Referenzclip und verarbeitet lange Synthese mittels automatischem Chunking.

```python
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–10s-Clip klonen
audio, sr = model.synthesize(
    text="Das ist meine geklonte Stimme, die ein Clore.ai-Hörbuchkapitel vorliest.",
    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 **sauberes** Referenzmaterial (keine Hintergrundmusik, kein Raumhall)
* Stimme nach Möglichkeit die Sprache von Referenz und Zieltext ab
* Vor dem Einlesen normalisieren und Stille kürzen (`librosa.effects.trim`)
* Für konsistente Langform-Erzählungen dieselbe Referenz über mehrere Aufrufe hinweg wiederverwenden

## Option D — GGUF auf llama.cpp-audio / torch-freiem ONNX

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

```bash
# Klone das Haupt-Repo mit den torch-freien Extras
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 Werkzeugen — großartig für Raspberry Pi, Android oder serverlose Funktionen, bei denen eine 200-MB-Binärdatei zählt.

## Clore.ai-GPU-Empfehlungen

**Du brauchst für Nano keine GPU.** Das ist der ganze Punkt. Aber wenn du Batch-Generierung oder die größeren Geschwister nutzen 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,10 $/Tag      |
| RTX 3090 24 GB      | 24 GB | Vollständiges TTSD-v1.0 (8B), Batch-Serving | ab 0,30 $/Tag      |
| RTX 4090 24 GB      | 24 GB | TTSD + SoundEffect parallel                 | ab 0,50 $/Tag      |

{% hint style="success" %}
Für 90 % der produktiven TTS-Workloads — Sprachagenten, IVR, Erzählung — ist eine **nur-CPU-Clore.ai-Box buchstäblich die günstigste praktikable Bereitstellung**. Miete sie, betreibe MOSS-TTS-Nano und vergiss GPU-Kosten.
{% endhint %}

## Anwendungsfälle

* **Hörbücher** — Langform-Erzählung mit konsistenter geklonter Stimme, automatischem Chunking
* **Sprachagenten** — Sub-Second-TTFB auf der Realtime-Variante für Konversations-KI
* **IVR / Telefonsysteme** — Bereitstellung nur auf CPU, 48-kHz-Stereo, 20 Sprachen
* **NPCs in Spielen** — leicht genug, um direkt in einem Spiel-Client ausgeliefert zu werden, Stimmendesign pro Charakter
* **Synchronisation** — mehrsprachiges Klonen für Lokalisierungspipelines
* **Podcast-Generierung** — MOSS-TTSD-v1.0 verarbeitet Multi-Sprecher-Dialoge nativ
* **Soundeffekte** — MOSS-SoundEffect fügt der Pipeline zeitgesteuerte FX hinzu

## Benchmarks / Qualität

* **MOSS-TTSD-v1.0** übertraf Doubao und Gemini 2.5-pro bei subjektiven Multi-Sprecher-Dialog-Bewertungen
* **Nano** liefert einen Echtzeitfaktor **< 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 Gesprächseinsatz
* Stereoausgabe mit 48 kHz ist ein deutlicher Fortschritt gegenüber 24-kHz-Mono-Konkurrenten in diesem Parameterbudget

## Fehlerbehebung

| Problem                                    | Lösung                                                                                                   |
| ------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
| `pynini` Installation per pip schlägt fehl | `conda install -c conda-forge pynini=2.1.6.post1 -y` dann WeTextProcessing neu installieren              |
| Stockende Audioausgabe 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, einzelner Sprecher und sprachlich passend sein                        |
| OOM bei TTSD-v1.0                          | Verwende FP16 (`model.half()`) oder wechsle zum 1.7B Local-Transformer                                   |
| Modell-Download bleibt hängen              | Setze `HF_HUB_ENABLE_HF_TRANSFER=1` und versuche es erneut                                               |
| Langsamer erster Lauf                      | Die erste Inferenz kompiliert Kernel / lädt \~400 MB Gewichte herunter — nachfolgende Läufe sind schnell |
| Torch-Konflikte mit anderen Modellen       | Verwende die `[llama-cpp-onnx]` Extras für eine torch-freie Umgebung                                     |

## Nächste Schritte

* [Kokoro TTS](/guides/guides_v2-de/audio-and-sprache/kokoro-tts.md) — die 82M-englisch-zuerst-Alternative, wenn du kein Multilingual brauchst
* [Voxtral TTS](/guides/guides_v2-de/audio-and-sprache/voxtral-tts.md) — 4B-Mistral-Modell, 9 Sprachen, GPU erforderlich, aber höheres Potenzial
* [XTTS (Coqui)](/guides/guides_v2-de/audio-and-sprache/xtts-coqui.md) — Sprachklonen für 17 Sprachen, nur GPU, größer
* [Whisper Transcription](/guides/guides_v2-de/audio-and-sprache/whisper-transcription.md) — kombiniere MOSS-TTS mit Whisper für vollständige Sprach-Pipelines
* [Miete eine GPU (oder CPU) auf dem Clore.ai-Marktplatz](https://clore.ai/marketplace)

***

*Zuletzt aktualisiert: 20. April 2026*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/audio-and-sprache/moss-tts.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.