TLDR: Commercial on-device TTS options are scarce. Most developers rely on open-source text-to-speech alternatives for on-device processing. Among ten on-device engines independently benchmarked on CPU, first-token-to-speech latency ranges from 128 ms (Picovoice Orca) to 44,710 ms (Chatterbox-TTS-Turbo), peak memory from 29 MB to 7.5 GB, and model size from 7 MB to 2,980 MB. Orca is the only engine that fits in under 30 MB of RAM and still produces natural-sounding speech, making it deployable on embedded hardware, mobile devices, and browsers where larger open-source models cannot run. This article compares latency, efficiency, platform support, and licensing for every engine in the benchmark, plus ReadSpeaker as a commercial embedded alternative.
What Is On-Device Text-to-Speech?
On-device text-to-speech (TTS) converts written text into spoken audio directly on the hardware running the application, with no network call to a cloud API. The TTS model, phoneme dictionary, and inference runtime all live locally. Audio generation happens in real time on the device's CPU, GPU, or specialized hardware, such as NPU, depending on the TTS engine.
This matters for production deployments in three ways. First, latency becomes deterministic: there is no network round trip, no queuing on a shared API endpoint, and no variance from server load. Second, data never leaves the device, which simplifies compliance with privacy regulations like GDPR and HIPAA. Third, the application works offline, in tunnels, aircraft cabins, factory floors, and anywhere else connectivity is unreliable.
The tradeoff has historically been voice quality. Cloud TTS APIs from Google, Amazon, Microsoft, and ElevenLabs run large transformer models on GPU clusters. On-device engines must fit within the memory and compute budget of a phone, Raspberry Pi, or browser tab. Recent advances in model compression and efficient architectures have narrowed this gap significantly, as the benchmark data below demonstrates.
On-device Text-to-Speech Engines in 2026
The on-device TTS space has expanded rapidly. Ten on-device engines are included in Picovoice's independent, open-source TTS benchmark, which measures latency and efficiency on identical hardware (AMD Ryzen 7 5700X, 64 GB RAM) using the same dataset of ~200 simulated voice assistant interactions. The benchmark code and data are published under Apache 2.0 on GitHub.
The engines span a wide range of architectures and tradeoffs:
Commercial On-device TTS
Orca Streaming Text-to-Speech
A commercial streaming TTS engine built for voice AI agents. Orca processes raw LLM tokens as they arrive (true streaming input and output) without waiting for sentence boundaries. At 7 MB model size and 29 MB peak memory, it is the smallest engine in the benchmark. Supported on Linux, macOS, Windows, Android, iOS, Raspberry Pi 3/4/5, and all major browsers via production SDKs. Commercial license only.
ReadSpeaker speechEngine SDK Embedded
The information below is sourced from ReadSpeaker's public product pages and documentation, not verified through a 3rd party benchmark due to its limited availability.
Voice footprints range from 6 to 35 MB per voice, with support for 50+ languages and 150+ voices. The SDK runs on iOS, Android, and embedded Linux, with custom porting available for other platforms through professional services engagements.
ReadSpeaker's pricing is license-based, determined by the number of licenses, contract duration, languages, and voice quality tier. Pricing is not published; it requires a sales engagement.
Cerence Edge SDKs
The information below is sourced from Cerence's website, not verified through a 3rd party benchmark due to its limited availability.
In 2019, Nuance Communications spun off its automotive and embedded mobility division to form Cerence. As of 2026, Cerence has consolidated its embedded voice technologies under the Cerence Edge SDKs, with the current major iteration being CSDK V9. Cerence TTS is built on a modular architecture, allowing devices to rely on high-fidelity cloud neural TTS when connected, but fall back to robust, on-device embedded TTS when offline or driving through dead zones.
Open-source TTS
Piper TTS
An open-source neural TTS using VITS models exported to ONNX. Piper offers 100+ voices across 30+ languages with model sizes ranging from low-quality (16 kHz) to high-quality (22.05 kHz) tiers. It runs from a CLI, Python API, or C library. Piper performs well on CPU: the benchmark measured a 0.54x core-hour ratio, meaning it synthesizes roughly twice as fast as real time on a single core. The tradeoff is memory (2.6 GB peak) and latency (1,510 ms FTTS), which limit mobile and embedded use. It's licensed under GPLv3, whereas the original one published by Rhasspy is MIT.
Kokoro TTS
Kokoro, 82-million-parameter model released under Apache 2.0 reached the top of the TTS Arena leaderboard (v1) on HuggingFace. Kokoro generates high-quality speech and supports English, French, Korean, Japanese, and Mandarin. It runs on CPU, but the benchmark shows 2,925 ms FTTS, 1.9 GB peak memory, and a 341 MB model, placing it as a better fit for the desktop/server deployment tier. No native mobile SDKs.
Pocket TTS
A compact model from Kyutai Labs designed for efficiency and released under the MIT license. At 242 MB model size and 617 MB peak memory, it sits in the mid-range tier. FTTS of 1,670 ms and a 0.37x core-hour ratio (second-best after Orca) make it a reasonable choice for desktop applications where sub-second latency is not required.
Kitten TTS Nano
Kitten TTS Nano, with an INT8-quantized model at 42 MB and 320 MB peak memory, released under Apache 2.0, is the second-most memory-efficient after Orca. However, it requires full audio synthesis before playback (no streaming output), resulting in 10,670 ms FTTS. Suitable for non-real-time batch processing where small model size matters.
Chatterbox-TTS-Turbo
Resemble AI released Chatterbox under the MIT license in 2025. It produces high-quality speech with voice cloning but requires 7.5 GB of memory and 44,710 ms per utterance, making it a better alternative for content requiring high-quality audio, such as audiobooks and podcasts, rather than real-time applications.
Other Open-source TTS Alternatives
Soprano TTS, Supertonic TTS 2, and Neu-TTS-Nano-Q4-GGUF (Neuphonic) fall in the 500 MB to 2.1 GB memory range with FTTS between 1,590 ms and 2,550 ms, making them a fit for desktop/server implementations with a response time in the middle range.
On-device TTS Comparison
On-device TTS Latency Benchmark
TTS latency numbers are measured as time-to-first-byte on identical hardware. FTTS (First Token to Speech) isolates TTS engine responsiveness by holding the LLM constant. VART (Voice Assistant Response Time) measures end-to-end latency from user request to first audio. According to turn-taking research in spoken dialogue, 100-300 ms feels instantaneous; above 700 ms, the interaction feels broken.
When evaluating TTS latency, lower FTTS and VART scores are better, with 200 ms considered the threshold for natural conversation. Orca Streaming TTS achieves 128 ms FTTS and 204 ms VART, the only engine under the 200 ms threshold for natural conversation. The next-fastest on-device engine, Piper TTS is ~12x slower at 1,510 ms FTTS. For enterprise deployments running thousands of concurrent sessions, Orca's 0.16x core-hour ratio and 29 MB memory footprint allow for significantly higher instance density on on-premise servers compared to open-source alternatives like Kokoro (1.9 GB memory).
All metrics below were measured on identical hardware (AMD Ryzen 7 5700X, 64 GB RAM) using a standardized dataset of 200 simulated voice interactions to ensure a 1-to-1 comparison.
| Engine | FTTS (ms) | VART (ms) | Streaming Mode |
|---|---|---|---|
| Picovoice Orca | 128 | 204 | Streaming in + out |
| Piper TTS | 1,510 | 1,587 | Streaming out |
| Soprano TTS | 1,590 | 1,665 | Streaming out |
| Pocket TTS | 1,670 | 1,744 | Streaming out |
| Supertonic TTS 2 | 2,450 | 2,526 | Streaming out |
| Neu-TTS-Nano Q4 | 2,550 | 2,629 | Streaming out |
| Kokoro TTS | 2,925 | 3,000 | Streaming out |
| Kitten TTS Nano | 10,670 | 10,741 | Single synthesis |
| Chatterbox-TTS-Turbo | 44,710 | 44,804 | Single synthesis |
Source: Picovoice Open-Source TTS Benchmark
On-device TTS Efficiency and Size Benchmark
Understanding the performance requirements of your Text-to-Speech (TTS) engine is critical for smooth deployment. Here is a breakdown of the core metrics to consider:
CPU Core-Hour Ratio (Synthesis Speed): This metric measures the CPU processing power required to generate one hour of audio.
Ratio of 1.0: The TTS engine utilizes exactly one CPU core for real-time synthesis.
Ratio Below 1.0: The engine is highly efficient, synthesizing audio faster than real-time on a single core.
Ratio Above 1.0: The engine operates slower than real-time on one core, which introduces latency.
Peak RAM Usage & Memory Management: This tracks the maximum Random Access Memory (RAM) the TTS engine consumes during audio generation, excluding overhead from Python setups or LLM inference.
Total device RAM does not equal available RAM, as background services (like networking and SSH) consume resources first. For real-time voice AI apps—especially on low-end mobile devices—your total memory budget should stay below 200 MB, as both iOS and Android automatically terminate high-consuming apps to prevent Out-of-Memory (OOM) crashes.
- Overall Model Size: This is the total binary file size required to run the TTS engine. It excludes standard Python libraries like PyTorch. Keeping the model size compact is essential for mobile and web applications, as it directly impacts your app's initial download size and the speed of over-the-air (OTA) updates.
Orca's 7 MB model is 425x smaller than Chatterbox-TTS-Turbo (2,980 MB) and 49x smaller than Kokoro (341 MB). At 29 MB peak memory, Orca is the only neural TTS engine that fits on embedded systems, web browsers, and low-end mobile devices.
| Engine | Core-Hour Ratio | Peak Memory | Model Size |
|---|---|---|---|
| Picovoice Orca | 0.16x | 29 MB | 7 MB |
| Pocket TTS | 0.37x | 617 MB | 242 MB |
| Piper TTS | 0.54x | 2.6 GB | 61 MB |
| Supertonic TTS 2 | 0.84x | 520 MB | 262 MB |
| Kokoro TTS | 1.4x | 1.9 GB | 341 MB |
| Kitten TTS Nano | 5.1x | 320 MB | 42 MB |
| Soprano TTS | 5.7x | 710 MB | 280 MB |
| Neu-TTS-Nano Q4 | 9.8x | 2.1 GB | 507 MB |
| Chatterbox-TTS-Turbo | 19x | 7.5 GB | 2,980 MB |
Source: Picovoice Open-Source TTS Benchmark.
On-device TTS Custom Pronunciation Support Comparison
For enterprise deployments, an on-device engine must correctly pronounce domain-specific terminology, proper nouns, and acronyms. Because on-device engines store the TTS model and phoneme dictionary locally, developers have varying degrees of control over pronunciation overrides depending on the engine's underlying architecture.
Orca TTS: Orca uses a lightweight inline syntax, such as
{cook|K UH K}. The word goes before the pipe, ARPAbet phonemes after it. No XML parsing, no separate lexicon file. This makes inline notation a natural fit for streaming TTS pipelines where SSML overhead adds latency. Orca also supports IPA subsets for non-English languages, extending pronunciation control beyond English.Piper TTS: Piper relies on an eSpeak-NG frontend to generate phonemes prior to audio synthesis. Developers can customize pronunciation natively by modifying the underlying eSpeak-NG dictionary or by passing inline phoneme notation directly into the input text string.
Kokoro TTS: Kokoro supports custom pronunciation through pipeline pre-processing rather than runtime dictionary overrides. Developers use its open-source CLI tools to convert text into International Phonetic Alphabet (IPA) phonemes, manually correct the IPA output for out-of-distribution words, and feed the corrected phonemes back into the synthesizer.
Chatterbox-TTS-Turbo: While Chatterbox lacks a traditional phoneme dictionary, it allows developers to generate multiple audio variants of a specific term and lock in the most accurate pronunciation for future generation requests.
Continuous Audio Models (Pocket TTS, Neu-TTS-Nano, Kitten TTS Nano): End-to-end architectures eliminate the discrete text-to-phoneme layer entirely. Because these models predict continuous audio representations directly from text tokens, there is no documented method for developers to inject custom dictionary rules or phonetic overrides.
On-device TTS Platform Support Comparison
Platform coverage determines where an engine can actually ship. Production applications targeting mobile, embedded, or browser environments need native SDKs, not just a Python package that happens to compile.
Orca Streaming TTS is the only engine with production SDKs across all deployment targets: desktop, mobile, embedded (Raspberry Pi 3/4/5), and browsers. Most open-source engines support desktop Linux/macOS/Windows but lack native mobile or browser SDKs.
Piper TTS supports desktop platforms and Raspberry Pi via CLI and C library, but has no official iOS SDK and no browser runtime. Kokoro TTS runs on desktop and in browsers (via ONNX.js) but has no mobile SDKs. Kitten TTS Nano and Supertonic TTS 2 cover desktop, mobile, embedded, and browsers. The full platform matrix is published on the Picovoice benchmark page.
Choosing the Right On-device TTS within the Compute Limits
The right on-device TTS depends on the deployment hardware and the latency budget. The benchmark data groups engines into four deployment tiers based on peak memory:
On-device TTS for all platforms, including embedded, mobile, web browsers, and desktop (<30 MB)
Only Orca Streaming Text-to-Speech (29 MB) fits this tier while producing neural-quality speech. For applications that must run on Raspberry Pi, low-end Android devices, or inside a browser tab alongside an LLM, Orca is the only neural option.
On-device TTS for Mid-range mobile and desktop apps (300 to 600 MB)
Kitten TTS Nano (320 MB), Supertonic TTS 2 (520 MB), and Pocket TTS (617 MB) fit mid-range devices. Pocket TTS offers the best core-hour ratio in this tier at 0.37x. None support streaming input.
On-device TTS for High-end mobile and desktop apps (600 MB to 1 GB)
Soprano TTS (710 MB) falls here. Viable on flagship phones but risks out-of-memory termination on budget devices, particularly when sharing memory with an LLM.
On-device TTS for desktop and server apps (Above 1 GB)
Kokoro TTS (1.9 GB), Neu-TTS-Nano (2.1 GB), Piper TTS (2.6 GB), and Chatterbox-TTS-Turbo (7.5 GB) are limited to desktop or server deployments. Kokoro and Piper produce high-quality speech and are strong choices for server-side batch generation or desktop-only applications where memory is not a constraint.
TTS Licensing for Commercial Use
Licensing determines whether an engine can ship in a commercial product. The open-source engines in this benchmark use a mix of permissive and copyleft licenses:
Apache 2.0 (permissive): Kokoro TTS, Pocket TTS. Free for commercial use with no restrictions.
MIT (permissive): Soprano TTS, Supertonic TTS 2. Free for commercial use.
GPLv3 (copyleft): Piper TTS (v1 fork). Requires releasing derivative source code under GPL. Linking GPL code into a proprietary mobile app may conflict with app store distribution terms.
Commercial: Orca Streaming Text-to-Speech, ReadSpeaker speechEngine SDK Embedded and Cerence Edge SDKs require official engagement with the IP owners.
If you're a developer, you can start building with Orca. If you're a budget owner, you can discuss your project scope and requirements with our sales team.
Talk to SalesFAQ
It depends on the target hardware. For embedded systems, mobile devices, and browsers, Picovoice Orca is the only engine under 30 MB of memory that produces natural-sounding speech (128 ms FTTS, 7 MB model). For desktop or server applications where memory is not constrained, Kokoro TTS (Apache 2.0, 82M parameters) and Piper TTS (30+ languages, 100+ voices) are strong open-source options. Orca is commercial, not open-source, but is the benchmark leader for on-device deployment.
Yes. All on-device TTS engines process text and generate audio locally, with no network connection required. The model, phoneme dictionary, and inference runtime are bundled with the application. This is one of the primary advantages over cloud TTS APIs, which fail when connectivity is unavailable.
In the Picovoice benchmark, the fastest on-device engine (Orca, 128 ms FTTS) is 2.6x faster than the fastest cloud API (ElevenLabs Streaming, 335 ms FTTS) and 11x faster than standard cloud APIs like Amazon Polly (1,540 ms) and Azure TTS (1,580 ms). On-device latency is also deterministic: it does not vary with network conditions or API load.
Most open-source TTS engines target desktop Linux and lack native iOS or Android SDKs. Piper TTS supports Android via C bindings. Kokoro TTS has no official mobile SDK. Among the benchmarked engines, only Picovoice Orca, Kitten TTS Nano, Supertonic TTS 2, and Neu-TTS-Nano provide both Android and iOS support.
Picovoice Orca's model is 7 MB with 29 MB peak memory, and it produces speech rated alongside engines 50 to 400 times its size in the benchmark's audio quality comparison. The next-smallest neural model is Kitten TTS Nano at 42 MB, though it requires 320 MB of peak memory and does not support streaming output.
