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;
    }
}