Kokoro-82M for MediaPipe & LiteRT-LM

Fully on-device, multilingual text-to-speech in a single file.

This is hexgrad/Kokoro-82M (82M-parameter StyleTTS 2 + ISTFTNet) packaged as a .litertlm bundle for the MediaPipe Text-to-Speech (TextToSpeech) Task and LiteRT-LM, Google's open-source on-device inference runtime, across Android, iOS, macOS, Python, Web, and C++. Everything needed to turn text into 24 kHz speech is inside the one file: INT8 acoustic + vocoder models, all 54 voices, and self-contained text front-ends (text normalization and grapheme-to-phoneme) for 9 languages / dialects — no Python, no network, and no external GPL phoneme libraries, so the whole stack is Apache-2.0.

• Languages: American & British English, Spanish, French, Italian, Brazilian Portuguese, Hindi, Mandarin Chinese, Japanese
• Voices: all 54 Kokoro v1.0 voices (see Languages & voices)
• Speed: synthesizes speech 6–10× faster than real time on a Galaxy S26 GPU with FP16 precision, with ~0.35 GB peak memory
• Quality: on an 800-sentence, 8-language intelligibility benchmark it matches or beats the original Kokoro running on a server (see Quality)

Which file should I use?

Both files contain the same acoustic model weights, voices and text front-ends, and their vocoder graph is exported so that intermediate values stay inside the FP16 range (enabling native FP16 GPU execution, which roughly halves vocoder latency compared to FP32). The two files differ only in how the vocoder is quantized:

• GPU version — vocoder convolutions use INT8 weights with floating-point activations, which the LiteRT GPU delegate runs natively on OpenCL, WebGPU and Metal GPUs. Run it with Delegate.GPU / --backend=gpu and the LiteRT GPU accelerator libraries next to the runner (on Android: prebuilt/android_arm64/*.so, see below). With Delegate.CPU / --backend=cpu, or when no GPU accelerator is available, the vocoder silently runs on the CPU instead: speech is still intelligible but may be noisier, so use kokoro_int8_fp16.litertlm for CPU-only devices.
• CPU/GPU version — the vocoder convolutions carry explicit dequantize ops so XNNPACK (CPU) also produces clean audio. This costs extra memory, so only pick it if you cannot use the GPU.

[!NOTE] The earlier FP32 .tflite preview that used to live at the root of this repo (three bucketed graphs + a fixed-length demo build, English only, CPU only) has moved to legacy/ and is deprecated. New integrations should use the .litertlm files above.

Download

pip install -U huggingface_hub

# Recommended: GPU version (295 MB, 54 voices across 9 languages / dialects)
hf download litert-community/Kokoro-82M kokoro_int8_gpu_fp16.litertlm --local-dir .

# Or: CPU/GPU version (when no GPU is available)
hf download litert-community/Kokoro-82M kokoro_int8_fp16.litertlm --local-dir .

---

MediaPipe Text-to-Speech Task Capabilities

When loaded with the MediaPipe TextToSpeech Task, Kokoro-82M supports:

• Single-file .litertlm deployment: Produces normalized 24 kHz mono 32-bit floating-point (float32) PCM audio in [-1.0, 1.0] with all 54 voices and 9-language G2P / text normalization built in—zero external GPL phoneme libraries or Python dependencies.
• Low-latency streaming speech synthesis (synthesizeStream / synthesize_stream): Automatically segments multi-sentence inputs at sentence and clause boundaries and streams AudioChunk buffers as each slice finishes synthesis.
• Real-time LLM-to-TTS token streaming (openStream / start_stream): Push incremental text deltas (pushText / push_text) directly from an on-device LLM stream and call finishInput / finish_input when done. Speech synthesis begins immediately once the first sentence boundary arrives.
• Word-level timestamp alignment (wordTimestamps / word_timestamps): Both unary AudioResult and streaming AudioChunk results include pause-aware WordTimestamp entries (word, startChar, endChar, startSec, endSec) mapped directly to character offsets in the input string for real-time read-along text highlighting.
• Fast voice & language switching: Switch across all 54 bundled voices and 9 languages per utterance using SynthesisOptions (voiceId, locale) without reloading model weights. When voiceId is set (e.g. "af_heart", "ef_dora", "zf_xiaobei", "jf_alpha"), the matching language is inferred automatically if locale is omitted.
• Speaking rate control & lock-free barge-in cancellation: Adjust speakingRate ((0.0, 4.0], default 1.0) and abort in-flight synthesis within milliseconds via cancel() or native Kotlin Coroutine / Swift Task cancellation.

---

Usage with MediaPipe Text-to-Speech Task

1. Android (Kotlin)

See the MediaPipe Text-to-Speech Android Guide and Android Sample App for a complete project setup.

Add the Gradle dependency

Add the MediaPipe Audio Tasks dependency to your module's build.gradle.kts (minSdk = 26, arm64-v8a):

dependencies {
    implementation("com.google.mediapipe:tasks-audio:latest.release")
}

Initialize the task and list voices

import com.google.mediapipe.tasks.audio.texttospeech.SynthesisOptions
import com.google.mediapipe.tasks.audio.texttospeech.TextToSpeech
import com.google.mediapipe.tasks.audio.texttospeech.TextToSpeechOptions
import com.google.mediapipe.tasks.core.BaseOptions
import com.google.mediapipe.tasks.core.Delegate

val options = TextToSpeechOptions(
    baseOptions = BaseOptions.builder()
        .setModelAssetPath("/data/user/0/com.example.app/files/kokoro_int8_gpu_fp16.litertlm")
        .setDelegate(Delegate.GPU) // Or Delegate.CPU with kokoro_int8_fp16.litertlm
        .build(),
    defaultVoiceId = "af_heart",
    speakingRate = 1.0f,
    cacheDirectory = context.cacheDir.absolutePath,
)

val tts = TextToSpeech.create(options)

// Enumerate all 54 bundled voices at runtime:
for (voice in tts.listVoices()) {
    println("${voice.voiceId} (${voice.displayName}) - locale=${voice.locale}, ${voice.sampleRateHz} Hz")
}

Unary synthesis & word-level timestamps

// Non-blocking coroutine synthesis (or use tts.synthesize(...) on a background thread):
val result = tts.synthesizeAsync(
    "Hello from Kokoro running on-device with MediaPipe Text to Speech!",
    SynthesisOptions(voiceId = "af_heart"),
)
// result.samples: FloatArray (24 kHz mono float32 PCM in [-1.0, 1.0])
// result.sampleRateHz: 24000
// result.durationSeconds: Float

// Word-level timestamps for synchronized read-along UI highlighting:
for (wt in result.wordTimestamps) {
    println("Word '${wt.word}' chars=[${wt.startChar}, ${wt.endChar}) time=${wt.startSec}s..${wt.endSec}s")
}

Streaming synthesis & incremental LLM-to-TTS streaming

// 1. Streaming a multi-sentence prompt sentence-by-sentence:
tts.synthesizeStream(
    "Streaming synthesis plays the first sentence right away. Subsequent sentences arrive while audio plays.",
    SynthesisOptions(voiceId = "af_heart"),
).collect { chunk ->
    streamingAudioTrack.write(chunk.samples, 0, chunk.samples.size, AudioTrack.WRITE_BLOCKING)
    // chunk.wordTimestamps provides word timing offsets for the current chunk
}

// 2. Incremental token-by-token streaming from an on-device LLM:
tts.openStream(options = SynthesisOptions(voiceId = "af_heart")).use { stream ->
    stream.pushText("Hello from an ")
    stream.pushText("on-device LLM! ")
    stream.pushText("Audio starts streaming before generation finishes.")
    stream.finishInput()

    while (true) {
        val chunk = stream.readNext() ?: break
        streamingAudioTrack.write(chunk.samples, 0, chunk.samples.size, AudioTrack.WRITE_BLOCKING)
    }
}

// Release native resources when done:
tts.close()

---

2. iOS & macOS (Swift)

See the MediaPipe Text-to-Speech iOS Guide and iOS Sample App.

Add the Swift Package

In Xcode, select File > Add Package Dependencies..., enter https://github.com/google-ai-edge/mediapipe, and add the MediaPipeTasksAudio library to your target.

Initialize and synthesize speech

import Foundation
import MediaPipeTasksAudio

let modelPath = Bundle.main.path(forResource: "kokoro_int8_gpu_fp16", ofType: "litertlm")!
let cacheDir = FileManager.default.temporaryDirectory
    .appendingPathComponent("mediapipe_tts_cache").path

let options = TextToSpeechOptions(
    baseOptions: TTSBaseOptions(
        modelAssetPath: modelPath,
        delegate: .gpu // Or .cpu with kokoro_int8_fp16.litertlm
    ),
    defaultVoiceId: "af_heart",
    speakingRate: 1.0,
    cacheDirectory: cacheDir
)

let tts = try createTextToSpeech(options: options)

// Enumerate bundled voices:
for voice in try tts.listVoices() {
    print("\(voice.voiceId) - locale=\(voice.locale), \(voice.sampleRateHz) Hz")
}

// 1a. Async unary synthesis:
let asyncResult = try await tts.synthesizeAsync(
    "Hello from Kokoro on Apple platforms!",
    options: SynthesisOptions(voiceId: "af_heart")
)
// asyncResult.samples: [Float] (24 kHz mono PCM), asyncResult.sampleRateHz: 24000

// 1b. Synchronous unary synthesis with word-level timestamps (run on a background thread):
let result = try tts.synthesize(
    "Hello from Kokoro on Apple platforms!",
    options: SynthesisOptions(voiceId: "af_heart")
)
for wt in result.wordTimestamps {
    print("\(wt.word) [\(wt.startChar)..<\(wt.endChar)]: \(wt.startSec)s - \(wt.endSec)s")
}

// 2. Low-latency streaming synthesis:
for try await chunk in tts.synthesizeStream(
    "Streaming synthesis emits 24 kHz PCM chunks as soon as each sentence completes.",
    options: SynthesisOptions(voiceId: "bf_emma")
) {
    // Schedule chunk.samples (24 kHz mono Float) onto AVAudioPlayerNode
}

// 3. Incremental LLM-to-TTS streaming:
let stream = try tts.openStream(options: SynthesisOptions(voiceId: "af_heart"))
defer { stream.close() }

try stream.pushText("Streaming tokens from ")
try stream.pushText("an on-device language model.")
try stream.finishInput()

while let chunk = try stream.readNext() {
    // Play chunk.samples & highlight chunk.wordTimestamps
}

---

3. Python

import soundfile as sf
from mediapipe.tasks.python.audio import text_to_speech
from mediapipe.tasks.python.core import base_options

options = text_to_speech.TextToSpeechOptions(
    base_options=base_options.BaseOptions(
        model_asset_path="kokoro_int8_fp16.litertlm"
    ),
    default_voice_id="af_heart",
    speaking_rate=1.0,
)

with text_to_speech.TextToSpeech.create_from_options(options) as tts:
    # List bundled voices
    for voice in tts.list_voices():
        print(f"{voice.voice_id}: locale={voice.locale}, {voice.sample_rate_hz} Hz")

    # 1. Unary synthesis + word-level timestamps
    result = tts.synthesize(
        "Hello from Kokoro running on-device with MediaPipe in Python!",
        voice_id="af_heart",
    )
    sf.write("output.wav", result.samples, result.sample_rate_hz)
    for wt in result.word_timestamps:
        print(f"{wt.word} [{wt.start_char}:{wt.end_char}] {wt.start_sec:.2f}s - {wt.end_sec:.2f}s")

    # 2. Streaming synthesis
    for chunk in tts.synthesize_stream(
        "First sentence streams right away. Second sentence follows seamlessly.",
        voice_id="af_heart",
    ):
        print(f"Chunk {chunk.chunk_index}: {len(chunk.samples)} samples (final={chunk.is_final})")

    # 3. Incremental LLM token streaming
    with tts.start_stream(voice_id="af_heart") as stream:
        stream.push_text("Streaming tokens ")
        stream.push_text("directly into Kokoro.")
        stream.finish_input()
        for chunk in stream:
            pass  # Play chunk.samples in real time

---

4. Web (JavaScript / TypeScript)

import { FilesetResolver, TextToSpeech } from "@mediapipe/tasks-audio";

const wasmFileset = await FilesetResolver.forAudioTasks(
  "https://cdn.jsdelivr.net/npm/@mediapipe/tasks-audio@latest/wasm"
);

const tts = await TextToSpeech.createFromOptions(wasmFileset, {
  baseOptions: {
    modelAssetPath: "kokoro_int8_gpu_fp16.litertlm",
    delegate: "GPU", // Or "CPU" with kokoro_int8_fp16.litertlm
  },
  defaultVoiceId: "af_heart",
  speakingRate: 1.0,
});

// List bundled voices
const voices = await tts.listVoices();
console.log("Available voices:", voices);

// 1. Unary synthesis
const result = await tts.synthesize(
  "Hello from Kokoro in the browser via MediaPipe WebAssembly!",
  { voiceId: "af_heart" }
);
// result.samples: Float32Array, result.sampleRateHz: 24000, result.wordTimestamps

// 2. Streaming synthesis
const stream = await tts.synthesizeStream(
  "Streaming speech directly to the Web Audio API.",
  { voiceId: "bf_emma" }
);
for await (const chunk of stream) {
  // Schedule chunk.samples (Float32Array at chunk.sampleRateHz) on AudioContext
}

// 3. Incremental LLM token streaming (finishInput = false)
const llmStream = await tts.synthesizeStream("", { voiceId: "af_heart" }, /* finishInput= */ false);
await llmStream.pushText("Streaming tokens ");
await llmStream.pushText("from WebGPU LLM into Kokoro.");
await llmStream.finishInput();
for await (const chunk of llmStream) {
  // Play chunk.samples and highlight chunk.wordTimestamps
}

tts.close();

---

5. C++

#include "mediapipe/tasks/cc/audio/text_to_speech/text_to_speech.h"

using ::mediapipe::tasks::audio::text_to_speech::SynthesisOptions;
using ::mediapipe::tasks::audio::text_to_speech::TextToSpeech;
using ::mediapipe::tasks::audio::text_to_speech::TextToSpeechOptions;
using ::mediapipe::tasks::core::BaseOptions;

TextToSpeechOptions options;
options.base_options.model_asset_path = "kokoro_int8_gpu_fp16.litertlm";
options.base_options.delegate = BaseOptions::Delegate::GPU;
options.default_voice_id = "af_heart";
options.speaking_rate = 1.0f;
options.cache_directory = "/tmp/mediapipe_tts_cache";

ABSL_ASSIGN_OR_RETURN(auto tts, TextToSpeech::Create(options));

// Unary synthesis:
SynthesisOptions synth_opts{.voice_id = "af_heart"};
ABSL_ASSIGN_OR_RETURN(auto result, tts->Synthesize("Hello from C++!", synth_opts));
// result.samples (std::vector<float>), result.sample_rate_hz (24000), result.word_timestamps

// Streaming synthesis:
ABSL_ASSIGN_OR_RETURN(auto stream, tts->SynthesizeStream("Streaming from C++.", synth_opts));
while (true) {
  auto chunk = stream->ReadNext();
  if (absl::IsOutOfRange(chunk.status())) break;
  ABSL_RETURN_IF_ERROR(chunk.status());
  // Consume chunk->samples and chunk->word_timestamps
}

---

Configuration Options Reference

TextToSpeechOptions

SynthesisOptions (per-utterance override)

---

Usage with LiteRT-LM Omni (omni_runner & C++)

Both commands below produce a 24 kHz mono WAV file. Prerequisites (Bazel, Android NDK) are in the LiteRT-LM build guide.

1. Download a model

pip install -U huggingface_hub
# Recommended: GPU version (any device with a LiteRT-supported GPU)
hf download litert-community/Kokoro-82M kokoro_int8_gpu_fp16.litertlm --local-dir .
# Or: CPU/GPU version (no GPU available)
hf download litert-community/Kokoro-82M kokoro_int8_fp16.litertlm --local-dir .

2. Build the runner

git clone https://github.com/google-ai-edge/LiteRT-LM.git && cd LiteRT-LM
# Pick ONE of the following; `bazel-bin/` always points at the last build.
bazel build -c opt //omni:omni_runner                            # Linux / macOS
bazel build -c opt --config=android_arm64 //omni:omni_runner     # Android (needs ANDROID_NDK_HOME; tested with NDK r28c)

If you build for both, copy the first binary out of bazel-bin/ before running the second build.

3. Synthesize speech

On a machine without a usable GPU (CPU):

bazel-bin/omni/omni_runner --model_name=kokoro \
    --model_path=/path/to/kokoro_int8_fp16.litertlm \
    --language=en-US --voice=af_heart \
    --text="Hello from Kokoro, running fully on device with LiteRT-LM." \
    --output_path=/tmp/hello.wav

On an Android phone (GPU, recommended):

DEVICE_DIR=/data/local/tmp/omni
adb shell mkdir -p $DEVICE_DIR
adb push bazel-bin/omni/omni_runner prebuilt/android_arm64/*.so \
         /path/to/kokoro_int8_gpu_fp16.litertlm $DEVICE_DIR

adb shell LD_LIBRARY_PATH=$DEVICE_DIR $DEVICE_DIR/omni_runner --model_name=kokoro \
    --backend=gpu --cache_dir=$DEVICE_DIR/cache \
    --model_path=$DEVICE_DIR/kokoro_int8_gpu_fp16.litertlm \
    --language=en-US --voice=af_heart \
    --text="Hello from Kokoro, running fully on device with LiteRT-LM." \
    --output_path=$DEVICE_DIR/hello.wav

adb pull $DEVICE_DIR/hello.wav .

--model_name=kokoro tells the runner which model family the file is. Keep it: builds before 2026-10-17 only infer it when the file is literally named kokoro.litertlm. The first GPU run compiles kernels and is slower; they are cached in --cache_dir so later runs start fast. GPU runs use FP16 precision by default; add --force_fp32_on_gpu for FP32 (about 2× slower).

Change --language and --voice to switch language (e.g. --language=ja --voice=jf_alpha). The full list of flags and the C++ OmniEngine / OmniSession streaming API are documented in the LiteRT-LM omni README.

Use from C++ (OmniEngine)

#include "omni/omni_engine.h"
#include "omni/omni_session.h"
#include "runtime/proto/text2speech_session_config.pb.h"  // //runtime/proto:text2speech_session_config_cc_proto

using ::litert::omni::OmniEngine;
using ::litert::omni::OmniSession;
using ::litert::omni::PushInputSource;

OmniEngine::Settings settings{
    .backend = OmniEngine::Settings::Backend::kGpu,
    .cache_dir = "/data/local/tmp/omni/cache",
    .model_path = "/data/local/tmp/omni/kokoro_int8_gpu_fp16.litertlm",
};
litert::lm::proto::Text2SpeechSessionConfig tts_config;
tts_config.set_language("en-US");
tts_config.set_voice("af_heart");

ABSL_ASSIGN_OR_RETURN(auto engine, OmniEngine::Create("kokoro", settings, &tts_config));
auto input_source = std::make_unique<PushInputSource>();
PushInputSource* input = input_source.get();
ABSL_ASSIGN_OR_RETURN(auto session, engine->CreateSession(std::move(input_source)));

ABSL_RETURN_IF_ERROR(input->PushInput(OmniSession::TextInput{.text = "Hello from Kokoro."}));
input->Finish();
// Pull OmniSession::AudioOutput chunks with session->ProcessNext() until
// OutOfRange or NotFound, then call session->Flush() (link //omni/text2speech:kokoro).

Languages & voices

Pass any of these codes to --language (aliases such as en, fr-FR, pt, zh-CN, cmn also work) and a matching voice to --voice. Voice names follow Kokoro's convention: first letter = language, second letter = female / male.

Voice descriptions and quality grades are in the upstream VOICES.md.

Samples

All clips were synthesized on a Samsung Galaxy S26 (--backend=gpu) and verified by transcribing them back with an ASR model.

Quality

How we measured. We synthesized 800 deliberately difficult sentences (100 per language × 8 languages: heteronyms, numbers, dates, currencies, abbreviations, liaison, tone sandhi, pitch accent, …) on a Samsung Galaxy S26 Ultra, transcribed the audio with Whisper large-v3, and computed the word error rate (WER; character error rate, CER, for Chinese and Japanese) against the input text. Lower is better.

For context, the self-contained front-ends in this release match or beat the reference host phonemizer sentence-for-sentence on 96 % of the 800 sentences (100/100 in Spanish and French, 98/100 Italian, 97/100 Portuguese, 99/100 Japanese). Most residual errors are text-normalization edge cases listed under Limitations or ASR spelling choices (e.g. e-mail vs email).

The text front-ends were also checked directly against Kokoro's reference host phonemizer (misaki): on a 100-word evaluation set per language they produce identical phonemes for English (US and UK), Spanish, French, Italian, Portuguese and Hindi.

Performance

Measured with head omni_runner on retail-equivalent phones, synthesizing an 18.3 s English paragraph (three sentences) with af_heart, 4 CPU threads, mean of 3 runs after one warm-up run. GPU runs use the default FP16 precision. RTF = synthesis time ÷ audio duration (lower is faster; 1.0 = real time). Peak memory is the process's peak resident set (VmHWM), including model load.

• Engine load time (model parse + GPU kernel cache load): 1.2–3 s on GPU, ~0.5 s on CPU. The very first GPU run on a device additionally compiles kernels (a few extra seconds); they are cached in --cache_dir.
• The GPU file keeps the vocoder's INT8 weights packed on the GPU, which is why it needs roughly half the memory of the CPU/GPU file (whose explicit dequantize ops materialize FP32 vocoder weights in host memory).
• CPU timings rise as the phone heats up (up to ~6 s on the S26 after several back-to-back runs).
• Long inputs are split into sentences / clauses and synthesized as a stream, so time-to-first-audio is roughly the synthesis time of the first sentence regardless of total text length.

GPU FP16 vs FP32

Galaxy S26 (SM-S942U1), head omni_runner, 4 CPU threads, one short paragraph per language, mean of 5 warm runs. FP16 is the default; FP32 is --force_fp32_on_gpu.

What's in the file

The models were exported from the original PyTorch checkpoint with litert-torch and quantized with the AI Edge Quantizer. No retraining or fine-tuning was done.

Limitations

• The acoustic model takes about 124 phonemes (~10 s of speech) per run. Longer sentences are split automatically, at punctuation when possible and otherwise between words, which can add a short pause mid-sentence.
• Mixed-script input works (e.g. English words inside Chinese text), but all-caps acronyms inside Chinese text are read as words rather than spelled out.
• Very large numbers (≥ 1,000,000) in Portuguese and Hindi and some 4-digit currency amounts in English may be read as years rather than cardinals.
• The GPU version needs a GPU supported by the LiteRT GPU delegate (OpenCL, WebGPU or Metal); it was tested on Qualcomm Adreno and Pixel (PowerVR). Use kokoro_int8_fp16.litertlm elsewhere.
• GPU FP16 output was verified on Qualcomm Adreno (Galaxy S26). If a GPU produces noisy audio in FP16, pass --force_fp32_on_gpu.

License & acknowledgements

• Weights: Apache-2.0, inherited from hexgrad/Kokoro-82M (trained by @rzvzn; architecture by StyleTTS 2 / ISTFTNet, Li et al.).
• Bundled lexicons: English from misaki (Apache-2.0); Japanese from unidic-lite (BSD); Chinese from jieba / pypinyin (MIT).
• Runtime: MediaPipe and LiteRT-LM (Apache-2.0).
• Training data, as disclosed by the upstream model: a few hundred hours of permissive / non-copyrighted audio with IPA labels. This conversion adds no training data and no personal information.