EMA Lightning — LiteRT (on-device Turkish TTS, 48 kHz)

EMA Lightning is an 8.6M-parameter Turkish text-to-speech model (a 5.6M flow-matching DiT distilled to four steps + a 3.0M HiFi-GAN decoder, one voice, 48 kHz), here as four static-shape LiteRT graphs (27.3 MB) converted with litert-torch 0.9.4 and run through LiteRT 2.2.0 CompiledModel: on a Galaxy S26 one 3.5 s sentence takes 52.5 ms (acoustic graphs on the CPU, the four DiT steps on the HTP, the decoder on the GPU at fp16), measured 2026-10-11; every graph is checked against the PyTorch package on six fixed sentences (tables below), and ema_host.py runs the whole thing without PyTorch.

Turkish only, one voice. The graphs read spoken-form, lowercased Turkish in the model's 49-symbol alphabet (a–z ç ö ü ğ ı ş, space and ! " % & ' ( ) , - . / : ; ?). Numbers, dates, amounts and abbreviations are turned into words by normalizer-tr (Rust, Apache-2.0; Python wheels on PyPI, a WebAssembly build exists) — that step is not inside the graphs. ema_litert.py runs it on a Mac / Linux / Windows host; an Android or iOS app either builds the crate natively or takes text that is already written out in words.

Files

Each graph file holds every bucket as a signature (one copy of the weights); the host picks the signature by the piece's length. Shapes are fixed per signature.

Weights: text fp32 (its fp16-weight file runs on the CPU but does not compile on the GPU delegate), aligner fp32, DiT steps fp32 (fp16 weights on the DiT failed the parity bar on one of six sentences), decoder fp16 (lossless-grade on the CPU, native on the GPU). 27.3 MB in all. config.json lists each file's sha256 and signatures.

pip install ai-edge-litert normalizer-tr numpy        # torch is optional: with it, seed 0 is the package's own take
python ema_host.py "Merhaba, bu ses telefonunuzun üzerinde üretiliyor." --out merhaba.wav --seed 0

How the host loop works

1. Normalize (normalizer-tr, "fallback" policy) → lowercase the Turkish way (İ → i, I → ı) → strip accents except Turkish letters → replace anything outside the alphabet with a space; cut into pieces of at most ~10 s at sentence, clause, then word boundaries (the package's chunker).
2. text: letters → h and per-letter frame counts. The host groups the counts per word, rounds them to whole frames (1–250 per word, ≤ 3000 per piece) and gives every frame a word and a position inside it (fw, fp), every letter a position inside its word (cg, fg in letters).
3. align: one condition vector per frame (each frame reads only its own and the adjacent words — the allow mask).
4. step × 4 with the seeded Gaussian noise: x1 = x + (1 − t)·v, then x = (1 − t')·noise' + t'·x1 (the package's DMD2-distilled sampler). The seed sets the take; seed 0 on CPU reproduces the PyTorch package's output.
5. decoder on windows of 25 frames (the first second, so audio starts early) then 100 frames, with 8 frames of context on each side cut away after decoding; the pieces join sample-exactly.

from ema_host import EmaLiteRT
tts = EmaLiteRT(threads=4)
audio, stats = tts.say("Merhaba, bu ses telefonunuzun üzerinde üretiliyor.", seed=0)  # float32 at 48 kHz

ema_host.py is ~250 lines of NumPy. Android sample: LiteRT-Models/ema-lightning — type Turkish, tap Speak, hear it; the same steps in Kotlin (acoustic graphs on the CPU, decoder on the GPU), the four graphs downloaded in-app from this repo; its screen for a 2.4 s sentence on a Galaxy S26: 49 ms, first audio 33 ms. Numbers and abbreviations must be written out in words there (the Rust normalizer is not in the app).

Performance (measured)

Galaxy S26 (Snapdragon, 12 GB), Android 16, LiteRT 2.2.0 CompiledModel, 2026-10-11. One call = write the inputs + run + read the outputs, median of 20 calls after 3 warm-ups on a rested phone (thermal status 0, no CPU cap). Per-graph times are for the shipped fp32 graphs; "GPU fp16" = the GPU at its default precision (fp16 activations).

HTP = LiteRT's NPU accelerator with the Qualcomm compiler plugin and runtime libraries (JIT, one HTP partition per graph); its step compile takes 1 s per process. The GPU compiles each graph once per process (0.3–0.7 s).

One 3.5 s sentence (60 letters, 88 frames: text + align + 4 steps + decoder windows P48 + P120):

The small acoustic graphs run faster on the CPU than on the GPU (per-launch overhead); the decoder is where the GPU pays off, and it is the wrong workload for the HTP. The base card's RTF figures are the authors' own (an RTX 4090 and a cloud CPU) and are not repeated here. Mac (M4 Max, ai-edge-litert 2.2.0 XNNPACK 4 threads, the same host loop): RTF 0.02–0.04, first audio 40–60 ms.

Parity with the PyTorch package

Reference = the pip package ema-lightning 1.1.2 on a CPU (fp32, seed 0, speed 1), six sentences (the base card's three "Listen" samples and three of our own: numbers, a date, a long sentence). Bar: the same frame timeline, latents corr ≥ 0.9999, audio SNR ≥ 30 dB on every sentence.

Forms that failed the bar and are not shipped: dynamic int8 weights anywhere (the four-step distilled DiT amplifies weight noise: 6–24 dB), fp16 weights on the DiT (one sentence at 26–28 dB), fp16 GPU activations on the text graph or the DiT steps. The published Hub clips (assets/sample-*.wav) have the same length as the package's CPU output but a different waveform (a different noise stream); they are not the reference.

Limitations

• Turkish only, one voice, no voice cloning (the base model's limitations).
• The text frontend (normalizer-tr) is a separate component; the graphs do not read digits or abbreviations.
• Fixed buckets: a piece longer than 256 letters / 512 frames is cut by the chunker first; speeds far from 1.0 may move a piece to a larger bucket.
• The shipped checkpoint has no self-attention in its text encoder (text_attn: 0 in ema.pt); the base card's architecture text describes two attention blocks.

License and attribution

Weights and code of EMA Lightning: Apache-2.0 (canberkkkkkk). normalizer-tr: Apache-2.0 (Erdem Tuna). This conversion: Apache-2.0. The base card asks that listeners be told they hear an AI-generated voice; that applies here too.