Redible TTS: cloud-level speech, running entirely on your phone

Why the voice has to live on the phone

Redible is an app for reading and listening to books in the language they were written in. Our own library is narrated in advance, book by book. But people also bring their own books — an EPUB bought somewhere, a classic from Project Gutenberg — and a book nobody has seen before cannot be narrated ahead of time.

So the voice for those books has to be on the phone. It has to start the moment you press play, keep going on a plane or in the metro, and never send the book anywhere. And it has to sound like a narrator, not like the robotic voice that phones have had for years.

We started from Qwen3-TTS, an open text-to-speech model from the Qwen team, in its 0.6B version, and taught it 18 fixed voices across seven languages. Then we made it small and fast enough to run on a phone — and checked, carefully, what that cost in quality.

Listen first

One sentence per language from the MiniMax multilingual test set, made by the Android build’s engine with the same files as in the app.

How intelligible is it?

The usual way to measure this is word error rate: let a speech recognizer transcribe the audio and count how many words come back wrong. Lower is better. We ran two open benchmarks through the phone build — Seed-TTS-eval English (1,088 sentences) and the MiniMax multilingual test set (100 sentences per language) — and transcribed everything with Whisper-large-v3-turbo.

Next to it are the numbers published for the original model and for two cloud services, on the same sentences:

And on Seed-TTS-eval English, next to the results published on the same set:

In other words: a model 5.6 times smaller, running on a phone, lands in the same range as the original model and the cloud services. We don’t read the table as “better than” anyone, and you shouldn’t either:

• The other models were measured cloning a voice from a short sample; ours speaks in its own fixed voices, which is an easier task.
• MiniMax and ElevenLabs numbers come from the MiniMax-Speech report and were transcribed with Whisper-large-v3; Qwen’s report does not name its recognizer. We used the turbo version of Whisper.
• Our numbers are scored with Whisper’s own text normalizer, so “1990” and “nineteen ninety” count as the same words; the other models’ numbers are as published, scored by their authors. The official Seed-TTS-eval script compares numbers literally and counts every one as an error, which says more about the script than about the voice.
• In the Russian set, 12 of the 100 reference sentences contain Latin letters in place of Cyrillic ones (“B” for “В”, “O” for “О”), so a perfect reading still counts as wrong. Without those lines our Russian error rate is 0.98 % on the remaining 88; the table keeps the full set, and the other models’ Russian numbers include those lines too.

We also listened. The sentences with the most “errors” were, almost every time, read exactly as written — the recognizer had misheard, added words, or invented a phrase out of silence.

What it takes on a phone

Speed matters most when you tap. Tap a word or a hint and you want to hear it now, so taps are served first. The iPhone figure is the median of 14 taps, with the 90th percentile at 149 ms; weaker Android phones stay under half a second. These times run from the request to the first audio ready from the engine; the phone’s own audio output adds a little on top.

In steady reading, the real-time factor is 0.067 on the iPhone and 0.096 on the Galaxy, which uses about 0.93 GB of memory. Battery use depends on the phone: 7–8 % an hour on the Galaxy. The iPhone stayed cool throughout. Part of the original model’s size is an encoder for voice cloning, which we don’t need.

How we got there

The short version: we combined randomized Hadamard rotations, GPTQ and quantization-aware training to shrink the model. We also replaced the original speech decoder with our own, smaller and faster one, built for phones. On Android the model runs on our own CPU kernels; on iPhone it is rebuilt for the Neural Engine. The two phone builds come from the same model but are tuned separately for each platform — the error rates above are for the Android build.

Two things happen before a sentence is spoken. First, the text is normalized: numbers, dates and abbreviations become words, the way a narrator would read them. Second, for Russian, where stress moves and changes meaning, the model has learned to read stress marks — an acute accent over the stressed vowel — so it puts the stress where the book does.

What we tested along the way:

• Intelligibility with a speech recognizer at every step, and the open benchmarks above for the final build.
• Thirty-minute listening runs with the screen locked and the voice changing every ten sentences: speed, battery, temperature, memory, and whether the audio ever ran dry.
• That the computer copy of the phone engine produces the same output as the phone itself.
• Listening to the worst sentences by ear, to tell the model’s mistakes from the recognizer’s.

How we measured

The benchmark sentences were generated by the Android build’s engine running on a Mac, with the same model files as in the app and the same sampling settings; we checked earlier that this copy produces the same output as the phone. Every sentence was spoken once, with a fixed random seed, with no picking the best of several tries. 1,783 of 1,788 sentences finished normally. The recognizer was Whisper-large-v3-turbo with the language set explicitly and greedy decoding. The reference is the original text of each set; both the reference and the transcript go through Whisper’s normalizer (the English one for English, the basic one for the other languages), and the error rate is counted over the whole set.

Sources: Seed-TTS-eval · MiniMax-Speech technical report (multilingual test set; MiniMax-Speech and ElevenLabs Multilingual v2 results, Table 2) · Qwen3-TTS technical report (Qwen3-TTS results, Seed-TTS-eval comparison) · Qwen3-TTS on GitHub