MeloTTS: 7.4K+ Stars — 多语言 TTS 基准对比 Coqui TTS、ChatTTS、Bark 2026

# Ubuntu/Debian
sudo apt-get update && sudo apt-get install -y espeak-ng libsndfile1 ffmpeg

# macOS
brew install espeak libsndfile ffmpeg

# 验证 espeak-ng
espeak-ng --version

# 创建虚拟环境
python -m venv melotts-env
source melotts-env/bin/activate

# 安装 MeloTTS
pip install melotts

# 下载日语词典（JA 支持必需）
python -m unidic download

git clone https://github.com/myshell-ai/MeloTTS.git
cd MeloTTS
pip install -e .
python -m unidic download

git clone https://github.com/myshell-ai/MeloTTS.git
cd MeloTTS
docker build -t melotts .
docker run -it -p 8888:8888 melotts

docker run --gpus all -it -p 8888:8888 melotts

from melo.api import TTS

# 语速可调
speed = 1.0
device = 'auto'  # 自动检测 GPU，无则回退到 CPU

text = "MeloTTS is working correctly on this machine."
model = TTS(language='EN', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'test_output.wav'
model.tts_to_file(text, speaker_ids['EN-Default'], output_path, speed=speed)
print(f"Audio saved to {output_path}")

# CLI 使用（pip 安装后）
melo "Hello, this is MeloTTS speaking." output.wav -l EN --speaker EN-US

# 列出可用说话人
melo --list-speakers

from melo.api import TTS

speed = 1.0
device = 'auto'

text = "Did you ever hear a folk tale about a giant turtle?"
model = TTS(language='EN', device=device)
speaker_ids = model.hps.data.spk2id

# 美式口音
model.tts_to_file(text, speaker_ids['EN-US'], 'en-us.wav', speed=speed)

# 英式口音
model.tts_to_file(text, speaker_ids['EN-BR'], 'en-br.wav', speed=speed)

# 印度口音
model.tts_to_file(text, speaker_ids['EN_INDIA'], 'en-india.wav', speed=speed)

# 澳式口音
model.tts_to_file(text, speaker_ids['EN-AU'], 'en-au.wav', speed=speed)

from melo.api import TTS

speed = 1.0
device = 'cpu'

# 中文说话人无缝处理英文单词
text = "我最近在学习machine learning，希望能够在未来的artificial intelligence领域有所建树。"
model = TTS(language='ZH', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'zh-mixed.wav'
model.tts_to_file(text, speaker_ids['ZH'], output_path, speed=speed)

from melo.api import TTS

speed = 1.0
device = 'cpu'

text = "こんにちは、これは日本語の音声合成テストです。"
model = TTS(language='JA', device=device)
speaker_ids = model.hps.data.spk2id

output_path = 'ja.wav'
model.tts_to_file(text, speaker_ids['JA'], output_path, speed=speed)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from melo.api import TTS
import tempfile
import os

app = FastAPI()

# 预加载支持的语言模型
models = {}
for lang in ['EN', 'ZH', 'ES', 'FR', 'JA', 'KO']:
    models[lang] = TTS(language=lang, device='auto')

class TTSRequest(BaseModel):
    text: str
    language: str = 'EN'
    speaker: str = 'EN-Default'
    speed: float = 1.0

@app.post("/tts")
async def text_to_speech(req: TTSRequest):
    if req.language not in models:
        raise HTTPException(status_code=400, detail=f"不支持的语言 {req.language}")
    
    model = models[req.language]
    speaker_ids = model.hps.data.spk2id
    
    if req.speaker not in speaker_ids:
        raise HTTPException(status_code=400, detail=f"找不到说话人 {req.speaker}")
    
    output_path = tempfile.mktemp(suffix='.wav')
    model.tts_to_file(req.text, speaker_ids[req.speaker], output_path, speed=req.speed)
    
    return {"audio_file": output_path}

uvicorn tts_api:app --host 0.0.0.0 --port 8000 --workers 2

version: '3.8'

services:
  melotts:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8888:8888"
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8888"]
      interval: 30s
      timeout: 10s
      retries: 3

import asyncio
import websockets
import json
from melo.api import TTS

model = TTS(language='EN', device='auto')
speaker_ids = model.hps.data.spk2id

async def tts_stream(websocket, path):
    async for message in websocket:
        data = json.loads(message)
        text = data.get('text', '')
        speaker = data.get('speaker', 'EN-Default')
        speed = data.get('speed', 1.0)
        
        # 流式传输音频块
        for chunk in model.stream_tts(text, speaker_ids[speaker], speed=speed):
            await websocket.send(chunk)

start_server = websockets.serve(tts_stream, '0.0.0.0', 8765)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()

import gradio as gr
from melo.api import TTS

model = TTS(language='EN', device='auto')
speaker_ids = model.hps.data.spk2id
speaker_names = list(speaker_ids.keys())

def synthesize(text, speaker, speed):
    output_path = '/tmp/gradio_output.wav'
    model.tts_to_file(text, speaker_ids[speaker], output_path, speed=float(speed))
    return output_path

iface = gr.Interface(
    fn=synthesize,
    inputs=[
        gr.Textbox(label="文本", value="Hello from MeloTTS!"),
        gr.Dropdown(choices=speaker_names, label="说话人", value="EN-Default"),
        gr.Slider(0.5, 2.0, value=1.0, label="语速")
    ],
    outputs=gr.Audio(label="生成音频"),
    title="MeloTTS Web UI",
    description="实时多语言文本转语音"
)

iface.launch(server_name='0.0.0.0', server_port=7860)

from melo.api import TTS
import functools

@functools.lru_cache(maxsize=6)
def get_model(language):
    """缓存模型加载器 —— 模型只加载一次并复用。"""
    return TTS(language=language, device='auto')

# 启动时预热所有语言
for lang in ['EN', 'ZH', 'ES', 'FR', 'JA', 'KO']:
    get_model(lang)
print("所有模型已加载完毕。")

from melo.api import TTS
import concurrent.futures

model = TTS(language='EN', device='cuda:0')
speaker_ids = model.hps.data.spk2id

texts = [
    "第一条待合成语句。",
    "第二条待合成语句。",
    "第三条待合成语句。",
]

def synth(text):
    output_path = f"batch_{hash(text)}.wav"
    model.tts_to_file(text, speaker_ids['EN-Default'], output_path)
    return output_path

# 并行批处理
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(synth, texts))

# 安装 gunicorn 和 uvicorn 工作进程
pip install gunicorn uvicorn

# 使用 4 个工作进程运行
gunicorn tts_api:app -k uvicorn.workers.UvicornWorker \
  --bind 0.0.0.0:8000 \
  --workers 4 \
  --timeout 120 \
  --max-requests 1000 \
  --max-requests-jitter 100

[Unit]
Description=MeloTTS REST API
After=network.target

[Service]
Type=simple
User=melotts
Group=melotts
WorkingDirectory=/opt/melotts
Environment=PYTHONPATH=/opt/melotts
Environment=CUDA_VISIBLE_DEVICES=0
ExecStart=/opt/melotts/venv/bin/gunicorn tts_api:app -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000 --workers 4
Restart=on-failure
RestartSec=5s

[Install]
WantedBy=multi-user.target

sudo cp melotts.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable melotts
sudo systemctl start melotts
sudo systemctl status melotts

from prometheus_client import Counter, Histogram, generate_latest
from fastapi import Response

# 指标
tts_requests = Counter('melotts_requests_total', 'TTS 请求总数', ['language', 'speaker'])
tts_duration = Histogram('melotts_duration_seconds', 'TTS 生成耗时')

@app.get("/metrics")
async def metrics():
    return Response(content=generate_latest(), media_type="text/plain")

@app.post("/tts")
async def text_to_speech(req: TTSRequest):
    with tts_duration.time():
        # ... 现有 TTS 逻辑 ...
        tts_requests.labels(language=req.language, speaker=req.speaker).inc()

upstream melotts {
    server 127.0.0.1:8000;
    keepalive 32;
}

server {
    listen 80;
    server_name tts.yourdomain.com;

    location / {
        proxy_pass http://melotts;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_connect_timeout 30s;
        proxy_send_timeout 120s;
        proxy_read_timeout 120s;
        
        # 速率限制
        limit_req zone=tts_zone burst=20 nodelay;
    }
}