Você paga quanto por mês no ElevenLabs? Trinta dólares? Cinquenta? E se eu te dissesse que um modelo open source com 82 milhões de parâmetros gera áudio tão bom quanto, roda na sua CPU velha e não cobra um centavo?

O Kokoro TTS chegou ao topo do TTS Arena em janeiro de 2026, passando por cima de modelos com 10x, 15x mais parâmetros. E o mais absurdo: ele roda mais rápido que tempo real em qualquer processador decente dos últimos dez anos. Sem GPU. Sem cloud. Sem assinatura.

Eu testei, comparei, coloquei pra rodar em Docker, e vou te mostrar exatamente como fazer o mesmo.

O que é o Kokoro TTS (e por que ele importa)

Kokoro é um modelo de text-to-speech com 82 milhões de parâmetros, lançado sob licença Apache 2.0. Pra ter uma noção do quão pequeno isso é: o XTTS v2 da Coqui tem centenas de milhões de parâmetros e precisa de GPU. O Chatterbox tem 500 milhões. O Kokoro faz mais com menos.

A versão 1.0 trouxe 54 vozes em 8 idiomas: inglês americano, inglês britânico, francês, espanhol, italiano, hindi, português brasileiro, japonês, coreano e mandarim. Sim, português brasileiro está na lista.

O modelo pesa menos de 1 GB em FP16. O container Docker completo ocupa cerca de 5 GB, incluindo dependências. Compare isso com qualquer solução que exige uma RTX 3090 e 12 GB de VRAM.

Mas o número que realmente importa é outro: no TTS Arena, benchmark comunitário onde humanos avaliam a qualidade das vozes, o Kokoro ficou em primeiro lugar. Acima do XTTS v2 (que treinou com mais de 10.000 horas de áudio). Acima do MetaVoice (1.2 bilhão de parâmetros e 100.000 horas de treino).

82 milhões de parâmetros. Primeiro lugar. Na CPU.

Setup em 5 minutos com Docker

A forma mais rápida de colocar o Kokoro pra rodar é usando o Kokoro-FastAPI, um container pronto que expõe uma API compatível com o formato da OpenAI. Isso significa que qualquer código que já usa a API de TTS da OpenAI funciona com o Kokoro sem mudar uma linha.

# Subindo o container (CPU only, ~5GB)
podman run -d --name kokoro-tts -p 8880:8880 ghcr.io/remsky/kokoro-fastapi-cpu

# Ou com Docker, se preferir
docker run -d --name kokoro-tts -p 8880:8880 ghcr.io/remsky/kokoro-fastapi-cpu

Abra http://localhost:8880/web no navegador. Pronto. Você tem uma interface web onde pode digitar qualquer texto, escolher a voz e gerar o áudio na hora.

Se você prefere a linha de comando:

curl -X POST http://localhost:8880/v1/audio/speech \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kokoro",
    "input": "Fala dev, hoje vamos falar sobre text-to-speech local.",
    "voice": "af_heart"
  }' \
  --output fala.mp3

O arquivo fala.mp3 está pronto pra usar. Sem API key, sem rate limit, sem surpresa na fatura.

Instalação nativa com Python

Se você quer mais controle (ou não quer Docker), a instalação via pip é direta:

# Dependência do sistema (tokenizador fonético)
sudo apt install espeak-ng

# Instalação do Kokoro
pip install kokoro>=0.9.4 soundfile torch

E o código mínimo pra gerar áudio:

from kokoro import KPipeline

pipeline = KPipeline(lang_code="a")  # "a" = American English

# Gerar áudio
generator = pipeline(
    "Kokoro is a lightweight text-to-speech model with remarkable quality.",
    voice="af_heart",
    speed=1.0
)

for i, (gs, ps, audio) in enumerate(generator):
    import soundfile as sf
    sf.write(f"output_{i}.wav", audio, 24000)
    print(f"Segmento {i} salvo: {len(audio)/24000:.1f}s")

O pipeline do Kokoro divide textos longos em segmentos automaticamente, então você pode passar um artigo inteiro e ele gera cada trecho sequencialmente.

Para português brasileiro, troque o lang_code:

pipeline = KPipeline(lang_code="p")  # "p" = Português brasileiro

Benchmarks: CPU velha vs CPU nova

Uma das coisas que mais me surpreendeu foi a performance em hardware antigo. O Ariya Hidayat (criador do PhantomJS, pra quem lembra) testou o Kokoro em três máquinas diferentes com o mesmo parágrafo de texto:

Um processador de 2013 gerou o áudio em menos de 5 segundos. Isso é mais rápido que tempo real pra maioria dos textos curtos. O Ryzen mais recente fez em 1.5 segundos, o que significa que pra cada segundo de áudio gerado, ele levou uma fração de segundo de processamento.

Agora compara com o XTTS v2, que é “sluggish on CPU” segundo a própria documentação. Ou com o Chatterbox, que precisa de GPU pra atingir velocidade de tempo real.

Kokoro vs XTTS v2 vs Chatterbox vs Piper

Essa é a pergunta que todo mundo faz: qual TTS local escolher? A resposta depende do que você precisa.

Pra deixar mais claro:

Escolha o Kokoro se: você quer a melhor qualidade de voz sem GPU, com licença comercial, e não precisa de clonagem de voz. Perfeito pra narração de conteúdo, audiobooks, acessibilidade, chatbots com voz.

Escolha o XTTS v2 se: você precisa de clonagem de voz em múltiplos idiomas e tem GPU disponível. Mas atenção: a licença CPML proíbe uso comercial.

Escolha o Chatterbox se: você quer clonagem de voz com licença MIT e controle de expressividade. Precisa de GPU.

Escolha o Piper se: você está rodando em hardware extremamente limitado (Raspberry Pi, IoT) e quer latência mínima. A qualidade é inferior, mas roda em qualquer lugar.

Integração com projetos existentes (API compatível com OpenAI)

Essa é a sacada que torna o Kokoro absurdamente útil na prática. O Kokoro-FastAPI implementa a mesma interface da API de speech da OpenAI. Se o seu projeto já usa openai.audio.speech.create(), basta apontar pra outro endpoint:

from openai import OpenAI

# Antes: usando a API da OpenAI ($15/1M caracteres)
# client = OpenAI(api_key="sk-...")

# Depois: usando Kokoro local (grátis)
client = OpenAI(
    api_key="not-needed",
    base_url="http://localhost:8880/v1"
)

response = client.audio.speech.create(
    model="kokoro",
    voice="af_heart",
    input="Seu texto aqui vai ser convertido em áudio de alta qualidade."
)

response.stream_to_file("output.mp3")

Em JavaScript, a mesma lógica:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "not-needed",
  baseURL: "http://localhost:8880/v1",
});

const response = await client.audio.speech.create({
  model: "kokoro",
  voice: "af_heart",
  input: "Text-to-speech local, sem custo, sem latência de rede.",
});

const buffer = Buffer.from(await response.arrayBuffer());
fs.writeFileSync("output.mp3", buffer);

Nenhuma mudança na lógica do seu código. Só muda a URL base. E de repente você saiu de $15 por milhão de caracteres pra zero.

Vozes disponíveis e como escolher

O Kokoro v1.0 traz 54 vozes categorizadas por idioma e gênero. O padrão de nomenclatura segue um sistema simples:

• af_ = American Female
• am_ = American Male
• bf_ = British Female
• bm_ = British Male

Algumas das vozes mais populares:

# Listar todas as vozes disponíveis
curl -s http://localhost:8880/v1/voices | jq '.voices[].name'

Vozes que se destacam nos testes da comunidade:

• af_heart: feminina americana, tom natural e agradável
• am_eric: masculina americana, boa pra narração técnica
• bf_emma: feminina britânica, tom profissional
• am_adam: masculina americana, tom conversacional

Você também pode combinar vozes (voice blending) usando a CLI:

# Misturando duas vozes (50/50)
kokoro-tts --voice "af_heart+am_eric" --text "Voz combinada" --output blend.wav

Casos de uso reais

Tá, a tecnologia é legal. Mas onde isso se aplica na vida real de um dev?

Audiobooks e narração de conteúdo. Se você tem um blog (como este), pode gerar versões em áudio de cada artigo automaticamente. O Kokoro suporta textos longos e divide em segmentos. Um script de 20 linhas resolve.

Acessibilidade. Aplicações que precisam de leitura de tela com voz natural. O Kokoro roda local, então funciona offline. Perfeito pra apps que não podem depender de internet.

Chatbots com voz. Conecte o Kokoro como backend de TTS do seu assistente virtual. Com a API compatível com OpenAI, a integração com frameworks como LangChain ou qualquer outro que suporte speech é trivial.

Automação de vídeos. Narração pra tutoriais, vídeos de produto, conteúdo pra redes sociais. Gera o áudio, joga no FFmpeg com as imagens e pronto.

Prototipagem rápida. Antes de pagar por uma voz profissional, teste o conceito com o Kokoro. Se o resultado já for bom o suficiente (e provavelmente vai ser), você economizou o custo do estúdio.

Leitura de e-books e PDFs. A CLI do Kokoro tem detecção automática de capítulos e seções. Você converte um EPUB inteiro em audiobook com um comando:

kokoro-tts --input livro.epub --voice af_heart --output audiobook/

Pipeline completo: blog post para áudio

Vou montar um pipeline prático que pega um artigo em Markdown, converte pra texto limpo e gera o áudio:

import re
import subprocess
from pathlib import Path
from kokoro import KPipeline

def md_to_text(md_path: str) -> str:
    """Remove formatação Markdown, mantém só o texto."""
    text = Path(md_path).read_text()
    # Remove headers, bold, italic, links, code blocks
    text = re.sub(r'#{1,6}\s+', '', text)
    text = re.sub(r'\*\*(.+?)\*\*', r'\1', text)
    text = re.sub(r'\*(.+?)\*', r'\1', text)
    text = re.sub(r'\[(.+?)\]\(.+?\)', r'\1', text)
    text = re.sub(r'```[\s\S]+?```', '', text)
    text = re.sub(r'`(.+?)`', r'\1', text)
    text = re.sub(r'\n{3,}', '\n\n', text)
    return text.strip()

def generate_audio(text: str, output_path: str, voice: str = "af_heart"):
    """Gera áudio a partir de texto usando Kokoro."""
    pipeline = KPipeline(lang_code="a")

    all_audio = []
    for _, _, audio in pipeline(text, voice=voice, speed=1.0):
        all_audio.append(audio)

    import numpy as np
    import soundfile as sf
    combined = np.concatenate(all_audio)
    sf.write(output_path, combined, 24000)
    print(f"Audio salvo: {output_path} ({len(combined)/24000:.1f}s)")

# Uso
text = md_to_text("artigo.md")
generate_audio(text, "artigo_audio.wav")

Com 30 linhas de código, qualquer artigo vira podcast. E você pode agendar isso num cron pra rodar toda vez que publicar algo novo.

Limitações (porque nada é perfeito)

Seria desonesto não falar dos pontos fracos. O Kokoro tem limitações claras:

Sem clonagem de voz. Se você precisa de uma voz específica (a sua, por exemplo), o Kokoro não resolve. Você fica limitado às 54 vozes incluídas. Pra clonagem, precisa ir de XTTS v2 ou Chatterbox.

Sem controle de emoção. Não dá pra pedir pro modelo falar com raiva, tristeza ou entusiasmo exagerado. O Chatterbox tem um “dial de exagero” de 0.0 a 1.0 que o Kokoro simplesmente não oferece.

Sem SSML. Se você precisa de controle fino (pausas exatas, pronúncia customizada, ênfase em palavras específicas), o Kokoro não suporta Speech Synthesis Markup Language.

Idiomas com qualidade variável. O inglês é excelente. Os outros idiomas estão melhorando, mas ainda não atingiram o mesmo nível de naturalidade. Português brasileiro funciona, mas não espere a mesma perfeição do inglês.

54 vozes pode não ser suficiente. Se você precisa de diversidade extrema de vozes (personagens diferentes pra um audiobook de ficção, por exemplo), 54 pode parecer limitado comparado com soluções que permitem clonagem.

Dito isso, pra 90% dos casos de uso de TTS, essas limitações são irrelevantes. Você quer gerar áudio com qualidade profissional, rodando local, sem pagar nada? O Kokoro faz isso melhor que qualquer outra opção open source hoje.

O futuro do TTS local

O Kokoro é um sinal claro de pra onde a coisa está indo. Modelos menores, mais eficientes, rodando em hardware comum. A mesma tendência que vimos com LLMs (Llama, Mistral, Phi) está chegando no TTS.

A Coqui fechou as portas. O ElevenLabs cobra caro. A API da OpenAI funciona, mas depende de internet e de um cartão de crédito. Enquanto isso, um modelo Apache 2.0 com 82 milhões de parâmetros senta no topo do ranking de qualidade.

Se você ainda está pagando por TTS como serviço pra projetos que rodam em servidor próprio, é hora de repensar. Um docker run e cinco minutos depois você tem a mesma qualidade, rodando na sua máquina, sem depender de ninguém.

O Kokoro não é só um modelo bom. É a prova de que TTS local de qualidade profissional deixou de ser futuro e virou presente.