MOSS-TTS (solo CPU, 100M)

Ejecuta MOSS-TTS: texto a voz multilingüe ultraligero de 100M parámetros, centrado en CPU, de OpenMOSS (MOSI.AI + Fudan NLP) en Clore.ai.

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 es solo 100M parámetros, se ejecuta 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 múltiples hablantes, diseño de voz y generación de efectos de sonido.

Publicado: 10 de abril de 2026 (Nano) · compilación ONNX para CPU 17 de abril de 2026 · Licencia: Apache 2.0

Si Kokoro domina el nicho de inglés occidental de 82M 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 desplegar 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)	serving de producción sin Torch
MOSS-TTS-GGUF	100M (Q4_K_M)	0 GB (CPU)	despliegues 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 con múltiples turnos, 180 ms TTFB
MOSS-VoiceGenerator	1.7B	4 GB	Diseño de voz a partir de prompts de texto
MOSS-TTSD-v1.0	8B	8 GB	Diálogo entre múltiples hablantes, pódcast largos
MOSS-SoundEffect	8B	8 GB	Generación de efectos de sonido con control de duración

Especificaciones clave

Especificaciones	Valor
Desarrollador	Equipo OpenMOSS · MOSI.AI · Laboratorio Fudan NLP
Arquitectura	Autoregresivo (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
Transmisión	Sí — decodificación por fragmentos en CPU
Licencia	Apache 2.0
HuggingFace	Equipo OpenMOSS
GitHub	OpenMOSS/MOSS-TTS-Nano · OpenMOSS/MOSS-TTS

¿Por qué MOSS-TTS?

• Despliegue sin GPU — Nano se ejecuta en 4 núcleos de CPU, sin CUDA ni Triton

• Salida estéreo de 48 kHz — calidad de difusió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 audio de referencia de ~3 s

• Rutas ONNX/GGUF sin Torch — distribúyelo con un binario de 200 MB

• La familia escala hasta — mismo tokenizador/API desde Nano hasta TTSD de 8B

• Apache 2.0 — uso comercial, sin restricciones

• De investigación seria — Fudan NLP + MOSI.AI, no es 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 requerido)	— (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

Consejo de Clore.ai: Nano literalmente no necesita GPU. Si ya tienes una máquina de Clore para otros trabajos, TTS es gratis. Si quieres una GPU para rendimiento por lotes o para ejecutar las variantes de 1.7B/8B, una RTX 3060 de 12 GB ($0.03–0.07/h) es excesivo.

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

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 en pip, usa conda-forge:
conda install -c conda-forge pynini=2.1.6.post1 -y

Inferencia a partir del audio de referencia + texto objetivo:

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:

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

Demo web (Gradio):

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

Opción B — Docker (CPU y GPU)

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

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

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

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

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

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 audio limpio (sin música de fondo ni reverberación de sala)

• Haz coincidir el idioma de la referencia y del texto objetivo cuando sea posible

• Normaliza y recorta el silencio antes de pasar el audio (librosa.effects.trim)

• Para una narración larga y consistente, reutiliza la misma referencia en todas las llamadas

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

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

# 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 — excelente para Raspberry Pi, Android o funciones sin servidor donde importa un binario de 200 MB.

Recomendaciones de GPU para Clore.ai

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

GPU	VRAM	Cabe en	Precio en Clore (aprox.)
Instancia solo CPU	—	Nano, Nano-ONNX, GGUF	desde $0.01/h
RTX 3060 12GB	12 GB	Nano + Local-Transformer + Realtime	desde $0.03–0.07/h
RTX 3090 24GB	24 GB	TTSD-v1.0 completo (8B), servicio por lotes	desde $0.07–0.21/h
RTX 4090 24GB	24 GB	TTSD + SoundEffect concurrente	desde $0.14–0.42/h

Para el 90% de las cargas de trabajo TTS de producción — agentes de voz, IVR, narración — una máquina 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.

Casos de uso

• Audiolibros — narración de formato largo con voz clonada consistente, fragmentació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 bastante ligero para integrarlo dentro de un cliente de juego, diseño de voz por personaje

• Doblaje — clonación multilingüe para canalizaciones de localización

• Generación de pódcast — MOSS-TTSD-v1.0 maneja de forma nativa el diálogo entre múltiples hablantes

• Efectos de sonido — MOSS-SoundEffect añade FX con duración controlada al flujo

Puntos de referencia / calidad

• MOSS-TTSD-v1.0 superó a Doubao y Gemini 2.5-pro en evaluaciones subjetivas de diálogo entre múltiples 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 la 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 vía pip	conda install -c conda-forge pynini=2.1.6.post1 -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 rara	La referencia debe ser de 3–10 s, limpia, de un solo hablante y con 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 el [llama-cpp-onnx] extras para un entorno sin Torch

Siguientes pasos

• Kokoro TTS — la alternativa en inglés primero de 82M si no necesitas multilingüe

• Voxtral TTS — modelo Mistral de 4B, 9 idiomas, requiere GPU pero con mayor techo

• XTTS (Coqui) — clonación de voz en 17 idiomas, solo GPU, más grande

• Whisper Transcription — combina MOSS-TTS con Whisper para flujos de voz completos

• Alquila una GPU (o CPU) en Clore.ai Marketplace

---

Última actualización: 20 de abril de 2026