# MOSS-TTS (solo CPU, 100M)

MOSS-TTS es una familia de generación de voz de código abierto de **OpenMOSS** (Institución de Innovación de Shanghái, en colaboración con **Fudan NLP** y **MOSI.AI**, dirigida por el Prof. Xipeng Qiu). El modelo insignia **MOSS-TTS-Nano** tiene solo **100M parámetros**, funciona en tiempo real en una **CPU de 4 núcleos sin GPU**, genera **estéreo de 48 kHz**, y admite **20 idiomas** con clonación de voz zero-shot. La familia completa escala hasta 8B para diálogo entre varios hablantes, diseño de voz y generación de efectos de sonido.

{% hint style="info" %}
**Publicado:** 10 de abril de 2026 (Nano) · compilación ONNX para CPU 17 de abril de 2026 · **Licencia:** Apache 2.0
{% endhint %}

Si Kokoro domina el nicho occidental en inglés de 82M de parámetros, MOSS-TTS-Nano domina el nicho **multilingüe centrado en CPU** : la misma filosofía de modelo pequeño, pero con estéreo de 48 kHz, 20 idiomas, clonación de voz y una ruta ONNX/GGUF sin Torch. Para cualquiera que quiera implementar TTS sin pagar por una GPU, este es el modelo.

### Familia MOSS-TTS

| Modelo                         | Tamaño          | VRAM                  | Ideal para                                              |
| ------------------------------ | --------------- | --------------------- | ------------------------------------------------------- |
| **MOSS-TTS-Nano-100M**         | 100M            | 0 GB (CPU, 4 núcleos) | Tiempo real, edge, IVR, en el dispositivo               |
| **MOSS-TTS-Nano-100M-ONNX**    | 100M            | 0 GB (CPU)            | servicio de producción sin Torch                        |
| **MOSS-TTS-GGUF**              | 100M (Q4\_K\_M) | 0 GB (CPU)            | implementaciones al estilo llama.cpp                    |
| **MOSS-TTS-Local-Transformer** | 1.7B            | 4 GB                  | GPU ligera, alta calidad objetiva                       |
| **MOSS-TTS-Realtime**          | 1.7B            | 4 GB                  | agentes de voz de múltiples turnos, TTFB de 180 ms      |
| **MOSS-VoiceGenerator**        | 1.7B            | 4 GB                  | diseño de voz a partir de indicaciones de texto         |
| **MOSS-TTSD-v1.0**             | 8B              | 8 GB                  | diálogo entre varios hablantes, pódcasts largos         |
| **MOSS-SoundEffect**           | 8B              | 8 GB                  | generación de efectos de sonido con control de duración |

### Especificaciones clave

| Especificación             | Valor                                                                                                                           |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| **Desarrollador**          | Equipo OpenMOSS · MOSI.AI · Laboratorio NLP de Fudan                                                                            |
| **Arquitectura**           | Autoregresiva (tokenizador de audio + LLM)                                                                                      |
| **Frecuencia de muestreo** | 48 kHz, estéreo                                                                                                                 |
| **Idiomas**                | 20 (zh, en, de, es, fr, ja, it, hu, ko, ru, fa, ar, pl, pt, cs, da, sv, el, tr, +1)                                             |
| **Clonación de voz**       | Zero-shot a partir de una referencia de \~3 s                                                                                   |
| **Streaming**              | Sí — decodificación por bloques en CPU                                                                                          |
| **Licencia**               | 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) |

### ¿Por qué MOSS-TTS?

* **Implementación sin GPU** — Nano funciona en 4 núcleos de CPU, sin CUDA, sin Triton
* **Salida estéreo de 48 kHz** — calidad de emisión, poco común en modelos de menos de 100M
* **20 idiomas** — más cobertura que Kokoro (\~5) a un tamaño similar
* **Clonación de voz zero-shot** a partir de \~3 s de audio de referencia
* **Rutas ONNX/GGUF sin Torch** — despliegue con un binario de 200 MB
* **La familia escala** — mismo tokenizador/API desde Nano hasta TTSD de 8B
* **Apache 2.0** — uso comercial, sin condiciones ocultas
* **Desde investigación seria** — Fudan NLP + MOSI.AI, no un proyecto de afición

## Requisitos

| Componente | Mínimo (Nano, CPU)          | Recomendado (Nano, CPU) | Familia completa (GPU)    |
| ---------- | --------------------------- | ----------------------- | ------------------------- |
| CPU        | 4 núcleos (x86\_64 / ARM64) | 8 núcleos               | 8 núcleos                 |
| RAM        | 4 GB                        | 8 GB                    | 16 GB                     |
| GPU        | — (no requerida)            | — (opcional)            | RTX 3060 12 GB+           |
| VRAM       | 0 GB                        | 0 GB                    | 4–8 GB                    |
| Disco      | 1 GB                        | 2 GB                    | 10 GB (8B + dependencias) |
| Python     | 3.12                        | 3.12                    | 3.12                      |

{% hint style="success" %}
**Consejo de Clore.ai:** Nano literalmente no necesita GPU. Si ya tienes una máquina de Clore para otro trabajo, el TTS es gratis. Si *quieres* una GPU para procesamiento por lotes o para ejecutar las variantes 1.7B/8B, una **RTX 3060 12 GB (\~$0.10–0.30/día)** es excesiva.
{% endhint %}

## Opción A — instalación con Python + inferencia rápida

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

# Si pynini falla con pip, usa conda-forge:
conda install -c conda-forge pynini=2.1.6.post1 -y
```

Inferencia a partir del audio de referencia + texto objetivo:

```bash
python infer.py \
  --prompt-audio-path assets/audio/en_1.wav \
  --text "Bienvenido a Clore.ai — el mercado descentralizado de GPU."
# Salida: generated_audio/infer_output.wav  (48 kHz estéreo)
```

O mediante el punto de entrada CLI:

```bash
moss-tts-nano generate \
  --prompt-speech ref.wav \
  --text "Hola desde MOSS-TTS Nano ejecutándose en CPU."
```

Demo web (Gradio):

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

## Opción B — Docker (CPU y GPU)

**Solo CPU** (Nano, imagen de \~1 GB):

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

**Variante GPU** (para 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"
```

## Opción C — clonación de voz zero-shot (referencia de 3 s)

MOSS-TTS-Nano clona una voz a partir de un breve clip de referencia y maneja la síntesis de formato largo mediante segmentación automática.

```python
from moss_tts_nano import MossTTSNano
import soundfile as sf

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

# Clona la voz a partir de cualquier clip limpio de 3–10 s
audio, sr = model.synthesize(
    text="Esta es mi voz clonada narrando un capítulo de audiolibro de Clore.ai.",
    prompt_audio_path="speaker_ref_3s.wav",
    language="en",
)
sf.write("cloned.wav", audio, sr)  # 48 kHz estéreo
```

**Consejos de calidad (adaptados del manual de XTTS — se aplican los mismos principios):**

* Usa 3–10 s de **referencia** limpia (sin música de fondo, sin reverberación de la sala)
* Empareja el idioma de la referencia y del texto objetivo cuando sea posible
* Normaliza y recorta el silencio antes de pasarla (`librosa.effects.trim`)
* Para una narración larga consistente, reutiliza la misma referencia en todas las llamadas

## Opción D — GGUF en llama.cpp-audio / ONNX sin Torch

Para dispositivos edge, backends móviles o en cualquier lugar donde no quieras PyTorch:

```bash
# Clona el repositorio principal con los extras sin Torch
git clone https://github.com/OpenMOSS/MOSS-TTS.git
cd MOSS-TTS
pip install -e ".[llama-cpp-onnx]"

# Descarga los pesos cuantizados GGUF (Q4_K_M)
huggingface-cli download OpenMOSS-Team/MOSS-TTS-GGUF --local-dir weights/

# O compilación ONNX pura (sin torch en absoluto)
huggingface-cli download OpenMOSS-Team/MOSS-TTS-Nano-100M-ONNX --local-dir weights-onnx/
```

Esta ruta funciona con herramientas compatibles con llama.cpp, ideal para Raspberry Pi, Android o funciones serverless donde importa un binario de 200 MB.

## Recomendaciones de GPU de Clore.ai

**No necesitas una GPU para Nano.** Ese es precisamente el punto. Pero si quieres generar por lotes o ejecutar sus hermanos mayores:

| GPU                    | VRAM  | Cabe en                                     | precio en Clore (aprox.) |
| ---------------------- | ----- | ------------------------------------------- | ------------------------ |
| **instancia solo CPU** | —     | Nano, Nano-ONNX, GGUF                       | desde **$0.01/h**        |
| RTX 3060 12 GB         | 12 GB | Nano + Local-Transformer + Realtime         | desde $0.10/día          |
| RTX 3090 24 GB         | 24 GB | TTSD-v1.0 completo (8B), servicio por lotes | desde $0.30/día          |
| RTX 4090 24 GB         | 24 GB | TTSD + SoundEffect concurrentes             | desde $0.50/día          |

{% hint style="success" %}
Para el 90% de las cargas de trabajo de TTS en producción — agentes de voz, IVR, narración — una **máquina de Clore.ai solo CPU es literalmente el despliegue viable más barato**. Arréndala, ejecuta MOSS-TTS-Nano y olvídate de las facturas de GPU.
{% endhint %}

## Casos de uso

* **Audiolibros** — narración de formato largo con voz clonada consistente, segmentación automática
* **Agentes de voz** — TTFB de menos de un segundo en la variante Realtime para IA conversacional
* **IVR / sistemas telefónicos** — despliegue solo CPU, 48 kHz estéreo, 20 idiomas
* **NPCs de juegos** — lo suficientemente ligero para integrarlo en un cliente de juego, diseño de voz por personaje
* **Doblaje** — clonación multilingüe para canalizaciones de localización
* **Generación de pódcasts** — MOSS-TTSD-v1.0 maneja de forma nativa diálogos entre varios hablantes
* **Efectos de sonido** — MOSS-SoundEffect añade FX con duración controlada al pipeline

## Puntos de referencia / calidad

* **MOSS-TTSD-v1.0** superó a Doubao y Gemini 2.5-pro en evaluaciones subjetivas de diálogo entre varios hablantes
* **Nano** ofrece un factor en tiempo real **< 1.0 en 4 núcleos de CPU** (es decir, más rápido que la reproducción)
* **Realtime** variante informa **\~180 ms de tiempo hasta el primer byte** para uso conversacional
* La salida estéreo de 48 kHz supone una mejora clara frente a competidores mono de 24 kHz en este presupuesto de parámetros

## Solución de problemas

| Problema                                   | Solución                                                                                                     |
| ------------------------------------------ | ------------------------------------------------------------------------------------------------------------ |
| `pynini` la instalación falla mediante pip | `conda install -c conda-forge pynini=2.1.6.post1 -y` y luego reinstala WeTextProcessing                      |
| Audio entrecortado en CPU                  | Asegúrate de tener 4+ núcleos físicos; desactiva la sobreasignación SMT/HT; usa la compilación ONNX          |
| La voz clonada suena extraña               | La referencia debe ser de 3–10 s, limpia, de un solo hablante y con el idioma coincidente                    |
| OOM en TTSD-v1.0                           | Usa FP16 (`model.half()`) o baja al Local-Transformer de 1.7B                                                |
| La descarga del modelo se detiene          | Establece `HF_HUB_ENABLE_HF_TRANSFER=1` y vuelve a intentarlo                                                |
| Primera ejecución lenta                    | La primera inferencia compila kernels / descarga \~400 MB de pesos — las ejecuciones posteriores son rápidas |
| Torch entra en conflicto con otros modelos | Usa los extras `[llama-cpp-onnx]` para un entorno sin Torch                                                  |

## Próximos pasos

* [Kokoro TTS](/guides/guides_v2-es/audio-y-voz/kokoro-tts.md) — la alternativa de 82M centrada en inglés si no necesitas multilingüe
* [Voxtral TTS](/guides/guides_v2-es/audio-y-voz/voxtral-tts.md) — modelo Mistral de 4B, 9 idiomas, requiere GPU pero con mayor techo
* [XTTS (Coqui)](/guides/guides_v2-es/audio-y-voz/xtts-coqui.md) — clonación de voz en 17 idiomas, solo GPU, más grande
* [Whisper Transcription](/guides/guides_v2-es/audio-y-voz/whisper-transcription.md) — combina MOSS-TTS con Whisper para flujos completos de voz
* [Alquila una GPU (o CPU) en el Marketplace de Clore.ai](https://clore.ai/marketplace)

***

*Última actualización: 20 de abril de 2026*


---

# Agent Instructions: 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-es/audio-y-voz/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.