Best TTS Models for Real-Time Applications

Total Latency = VAD detection delay    (~100-200ms)
              + STT transcription        (~200-500ms, streaming models faster)
              + LLM first token          (~300-800ms, depends on model/provider)
              + TTS first audio chunk    (~100-500ms, the focus of this article)
              ─────────────────────────────────────────────────────────────────
              Total:                     ~700ms - 2000ms
              
Target: Keep total under 700ms for natural conversation feel.
TTS budget: 100-200ms first chunk latency to leave room for other stages.

import asyncio
from openai import AsyncOpenAI
from kokoro import KPipeline
import sounddevice as sd
import numpy as np

openai_client = AsyncOpenAI()
tts_pipeline = KPipeline(lang_code='a')

SENTENCE_ENDINGS = {'.', '!', '?', ':'}

async def stream_llm_to_tts(user_message: str):
    """
    Pipeline that starts playing audio before the LLM finishes generating.
    Key: split LLM output at sentence boundaries, generate TTS per sentence.
    """
    llm_stream = await openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": user_message}],
        stream=True,
        max_tokens=150,
    )
    
    sentence_buffer = ""
    audio_chunks = []
    
    async for chunk in llm_stream:
        delta = chunk.choices[0].delta.content or ""
        sentence_buffer += delta
        
        # Check if we have a complete sentence
        if sentence_buffer and sentence_buffer[-1] in SENTENCE_ENDINGS:
            sentence = sentence_buffer.strip()
            sentence_buffer = ""
            
            if sentence:
                print(f"Synthesizing: {sentence}")
                
                # Generate TTS for this sentence while LLM generates the next
                for _, _, audio in tts_pipeline(sentence, voice='af_heart'):
                    audio_chunks.append(audio)
                    # Play chunk immediately as it arrives
                    sd.play(audio, samplerate=24000, blocking=False)
                    await asyncio.sleep(len(audio) / 24000)  # Yield for duration of chunk
    
    # Handle any remaining text
    if sentence_buffer.strip():
        for _, _, audio in tts_pipeline(sentence_buffer.strip(), voice='af_heart'):
            sd.play(audio, samplerate=24000, blocking=False)
            await asyncio.sleep(len(audio) / 24000)

asyncio.run(stream_llm_to_tts("Explain quantum computing in 2 sentences."))

from kokoro import KPipeline
import time

pipeline = KPipeline(lang_code='a')

text = "Hello, how can I help you today?"

start = time.time()
first_chunk = True

for _, _, audio in pipeline(text, voice='af_heart'):
    if first_chunk:
        print(f"First audio chunk: {(time.time() - start)*1000:.0f}ms")
        first_chunk = False
    # Stream chunk to audio output
    # play(audio, samplerate=24000)  # ~85ms on Apple M2 CPU

# Install Piper
pip install piper-tts

from piper.voice import PiperVoice
import wave

# Load voice model (~60MB)
voice = PiperVoice.load("en_US-lessac-medium.onnx")

with wave.open("output.wav", "w") as wav_file:
    voice.synthesize("Hello from the edge device!", wav_file)

# Or stream directly to speakers:
import pyaudio

p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1,
                rate=voice.config.sample_rate, output=True)

for audio_bytes in voice.synthesize_stream_raw("Hello from the edge device!"):
    stream.write(audio_bytes)  # Real-time streaming playback

# Latency: <50ms first chunk on Raspberry Pi 4 -- genuinely impressive