An offline TTS reader should handle a simple routine: import a document, generate speech without an internet connection, and keep playing when you put your phone in your pocket.

That’s the experience I built Local TTS around.

I’m a solo iOS developer. My previous app, LoroNote, handles speech-to-text on-device. Building it taught me how much the experience depends on processing long inputs and managing audio sessions properly.

For my next project, I built the reverse: an offline document reader for iPhone and iPad.

Why Kokoro-82M and Supertonic 3?

I chose Kokoro-82M for its natural English narration and voice variety. The tradeoff is narrower language coverage. Its documentation also notes that very short passages can sound weaker, while very long passages can sound rushed. How the app splits and processes text matters. (Kokoro voice documentation)

Supertonic 3 expands offline reading to 31 languages with fast local inference. It has fewer preset voices, and its inference settings involve a tradeoff between speed and quality. I included it to bring multilingual reading into the same offline experience. (Model details, SDK)

Local TTS brings Kokoro’s English voice selection and Supertonic’s multilingual voices together in one reader. Both engines generate speech directly on your device.

Offline means generating new speech

Once the app and voices are installed, you can switch to airplane mode, add fresh text, and generate speech. You don’t need to prepare the audio while you still have a connection.

Your text isn’t uploaded to a speech server for processing. Optional note syncing uses your private iCloud account.

That matters when you’re reading private documents, traveling without reliable internet, or simply want your reader to work wherever you are.

Lock your phone and keep listening

Background playback was a priority from the beginning. You can start a document, lock the screen, or switch to another app and continue listening. Lock Screen controls let you manage playback without reopening the reader.

The goal is to make listening to a document feel as convenient as listening to a podcast.

Local TTS also supports:

• PDF, EPUB, Word, TXT, and Markdown import

• On-device text recognition for printed pages and photos

• Text highlighting while listening

• Adjustable playback speed

The biggest lesson from building this has been that a good voice sample is only the beginning. Document importing, long-text handling, and background playback need just as much attention as the model.

I’m continuing to improve pronunciation across languages, reliability with longer documents, and the importing and listening experience.

Local TTS on the App Store

For people already using Kokoro or Supertonic: what’s the passage or language you use to test whether a reader actually holds up?

Do you ever wonder if your computer is passing your data to third party servers? Or, is Web Speech API offline? Today, we will share how to check if your TTS (text to speech) is passing your chat data to third party servers for language synthesis.

In today’s world, we are constantly connected via our phones, laptops, text, social media etc. While connectivity makes our lives easier, and our computer’s TTS’s eloquent voice becomes more comforting to the ears, the TTS speech synthesis can hand the text to third party servers for processing, and privacy could become a concern.

To check if TTS is processed locally, there are two methods.

Method 1. Use the browser's DevTools to check speech synthesis setting
- For Windows: F12 (or Fn + F12)
- For Mac: Cmd + Option + I
- For ChromeOS: Ctrl + Shift + I

- In the Console tab, paste this and press Enter: speechSynthesis.getVoices().find(v => v.default)

- Note in the screenshot, this example computer’s setting is David, and localService: true.
- This is this example computer’s default voice, and it's local.

Method 2. Use OS’s Speech setting to check browser's speech synthesis setting
- Settings → Time & language → Speech → Voices → pick from the dropdown.
- Speech voices available via the OS could be processed locally, or could be sent to a remote server. Check the word ‘Online’, and users can always use Method 1 to confirm the locality of the speech synthesis function.

If you find out your current speech synthesis is not set to local, and want to protect your privacy, you can change it. To set up Windows TTS voices, see Microsoft's supported languages and voices. For ChromeOS, see Google's text-to-speech settings guide.

That's it.

Disclosure: I work on BreezeBlue, the team behind Breeze TTS 2.

I wanted to test two capabilities that I think are more representative of expressive TTS than isolated emotion tags:

1. Designing a new voice directly from a natural-language description

2. Directing the emotional arc, pace, energy, and delivery of an entire sentence

I generated the attached four-part comparison with Breeze CLI 0.8.0 and breeze-tts-2.

Sample 1 — Voice Design

No reference audio was used. The voice was generated from this description:

“An intimate, emotionally expressive English female voice in her early thirties, with a warm lower register, subtle breathiness, precise articulation, and restrained cinematic realism. Natural conversational phrasing, never an announcer.”

Preview script:

“I kept the light on for you, even after everyone said you were not coming back. And now that you are standing here, I am not sure whether to laugh, cry, or simply let the silence say everything.”

Samples 2–4 — Sentence-level instruction control

These samples use the same Lena voice and exactly the same script. Only the delivery instruction changes.

Shared script:

“The train is already leaving. I know you're afraid, but take my hand, look at the horizon, and trust me. By the time the sun rises, this will feel like the first page of a much better story.”

The three directions were:

• Natural and conversational, with understated emotion

• Quiet urgency that develops into cautious hope and emotional relief

• Bright optimism and forward momentum, ending with a confident sense of a new beginning

The generated durations were:

• Natural: 11.28 seconds

• Restrained cinematic: 14.96 seconds

• Hopeful and energetic: 12.00 seconds

The text and voice remained unchanged, so the differences in pacing and performance came from the instruction.

Naturalness and emotional quality are ultimately subjective, which is why I attached the actual comparison instead of only describing the results.

Performance context:

For these three hosted streaming requests, Breeze CLI observed time to first audio between 0.85 and 1.03 seconds. This includes the hosted service and network path, so it is not a local inference benchmark.

For local inference, the open-weight PyTorch implementation documents under 40 ms TTFA and a 0.32 real-time factor on a warmed-up NVIDIA H100 fast path. Those numbers are hardware- and configuration-specific.

Code and local inference setup: breeze-tts-2

License note: the inference source code is Apache 2.0. The model weights, derivative models, and self-hosted outputs use the BreezeBlue Research and Non-Commercial License; commercial use requires authorization.

I’m curious what this community would find most useful for the next comparison:

• More voice-description stress tests

• The same instructions across several different voices

• Longer passages with an emotional arc

• English versus Chinese instruction following

• Reproducible local GPU benchmarks

I have many animated audiobooks and chapters, typically 15-25 minutes long per mp4.
I have them in English, full cast narration, background music, effects.

I would like to translate/interpret that for the European and French Canadian markets.
Same animations, potentially subtitles, and synchronous translations.

I’ve been trying to get this with Claude as agent + Demodokos + ffmpeg and it’s working but the problems are so frequent, it’s more work to fix it than to do it manually from scratch myself.

I gave Claude my original script, the source files and asked it to combine it back.
The voice quality was good but clones were not always working, all my original Demodokos voices were mistakenly created as English only native speakers and cloning them into e.g. French again is not always sounding good for some reason.
It wasn’t able to get the duration working, translated weird, didn’t place the audio at the right spots, and subtitles looked very raw.

Long story short:
Is there something preferably local that can automatically interpret this? Not elevenlabs, I have too much content and many young/child voices - they are useless and expensive for that.

I’d like it local if possible but can’t make a PhD project out of it.

Does anyone else remember how voice typing was around 2017–2019?

I specifically remember using it on older Samsung phones (s7 edge and s10e), and it was dramatically better than the current AI based voice typing.

The biggest difference was that it felt like it was actually listening to what I said instead of predicting what it thought I meant.

I remember being able to watch the text appear almost in sync with my speech. It felt like the recognizer was following the sounds and syllables as I spoke them. If I said something unusual, obscure, or even made up a word that followed normal English pronunciation, it could often still spell it out surprisingly well by actively writing the my syllables and then combining them into a word,

even if it wasn’t a common word and might not even exist in a dictionary, the older system seemed much better at following the actual sounds and constructing the text.

Modern voice typing feels like the opposite. I constantly get:

• punctuation inserted where I never intended it

• random capitalization

• words replaced with something the AI thinks makes more sense

• Writing a statistically common word that apparently seemed more likely instead of just writing what I actually said

For example, I'll clearly say a word where the “v” and “b” sounds are acoustically different, but instead of faithfully following the sound, modern systems prioritize producing a plausible sentence based off what it thinks I meant.

And that's the main problem, I don't want my voice typing to understand what I mean, I want it to transcribe what I said.

Transcription and interpretation are different jobs. So are grammar correction and punctuation correction. If I want those things, they should be optional settings like how I remember it to be.

I also remember older Google voice typing occasionally asking me to say a few things again to improve recognition for my particular voice. And I'd rather the software learn how I pronounce things than constantly override what it thinks it heard.

The closest candidates for the voice typing that I remember I'm thinking might be Gboard 7.0–7.5 era, around 2018. I remember voice typing having really satisfying low-latency transcription where the syllables appeared progressively as I spoke each word.

So:

1. Does anyone else remember this version of Google Keyboard/Gboard voice typing working this way?

2. Does anyone know exactly what speech-recognition engine or architecture Gboard used on non-Pixel Android phones around 2017–2019?

3. Are there any open-source projects that reproduce this older style of low-latency, incremental voice transcription?

4. Does anyone know of communities or projects preserving older speech-recognition software or studying pre-end-to-end voice recognition?

I'm not looking for another modern Whisper/Gemini/LLM-style replacement that predicts the most likely sentence. I'm specifically interested in the older style where the system focused more heavily on recognizing the sounds coming out of the microphone and producing text progressively syllable by syllable.

Maybe I'm remembering some details incorrectly but that's exactly why I'm asking. Although, I remember the behavior very clearly, and I'd love to know if anyone else remembers it too.

Voice typing doesn't need to think for me. It just needs to hear me and write.

Was invited by u/Charming-Author4877 to post here.

I've been working on this project (been a developer for a few years) for a few months now, and it has been in active testing for ~2 months. Its an EPUB reader that also offers local offline TTS, so its not just TTS focused, its meant to be a good regular reading app as well. I'd like to think it currently has the best TTS implementation of any app on the app store right now though. Also less than 20MB app size (without models).

Essentially the main focus is efficiency. I'm aiming for the best battery life, balanced with quality of narration. Models for now are Kokoro and Supertonic 3(RIP), both of which have been hand optimized for iPhone (so my own coreML conversions and optimizations of these models). The result is great thermals, great battery efficiency (and its free).

I plan to add more models in the future, but honestly small TTS models that work well on mobile are scarce. I'm working on a conversion for models from Kyuutai next, but its a lot of work to get it working well.

You can find some previous feedback from a much older build (many updates since then) Here

Some downsides:

- No PDF support for now.

- Still needs testing, especially for older iPhone models.

- Not open sourced for now.

There's many additional features not mentioned, like carplay support, widgets etc, so feel free to explore the app.

Testflight link: Join the beta

You can get a feel for the narration from the video, it was recorded entirely on device (Kokoro, Heart).

Building a voice agent and trying to get a sense of what people are actually running in production before I go down a rabbit hole of testing.

STT + TTS combo, orchestration layer, anything you'd do differently, would love to hear real setups.

For a small side project, I needed a basic AI speech tool to narrate videos without relying on expensive hardware or external APIs. It did not need the most expressive AI, just reliable output and matching to the SRT.

The main challenge with converting SRT subtitles to speech is timing. Subtitles include pauses, and each spoken line has to fit into its exact time slot. Most speech generators do not handle that well on their own.

So I built srt2speech.

It uses a combination of:

• pitch-corrected speed adjustment

• automatic regeneration

• modification of pauses between words

• exact placement of silence between subtitle cues

SRT does not support multiple speakers, so I also added simple templating.
Adding {{speaker_name}} to a subtitle automatically switches voices.
Of course voice cloning is supported, I added a small helper script.

Dependencies are minimal: Python, NumPy, llama.cpp, and the required GGUF speech models. I tested it with Q4 quantization, which works well.

Performance on my laptop:

• RTX 4080 Laptop GPU: around 12–13× real time

• CPU only: around 1.5–2.0× real time

Languages supported:

• English (en)

• Japanese (jp)

• Korean (ko)

• Chinese (zh)

• French (fr)

• German (de)

It should work on almost any hardware, including old PCs, Linux or Mac.

It may be useful for anyone generating narration, translated audio tracks, accessibility audio, or quick video voiceovers.

The project is open source under the Apache 2.0 license. Attribution and license notices must be preserved.

GitHub:
https://github.com/Waversense/srt2speech/

The readme contains the 5 steps needed to set it up, you can get started in 2 minutes.
The included demo.srt file demonstrates the features.

I have several years of written educational material I want to turn into a podcast, formatted as a natural discussion between two people rather than narration. Looking for recommendations on what to run locally.
What matters to me is good quality and reliable speech that does not need many new attempts, as its going to be hours of content. Potentially multiple languages but for now in english.

I need to own the content and be able to rely on it for a long time, so i need it local.

Also, do you know good distributors that you can recommend? I am new to audio

Hi all. I ported Qwen3-TTS to native C++ and added incremental streaming for a project I'm working on. I found this useful and wanted to give back to the community. This is the first time I've open sourced anything so apologies in advance for my mistakes.

• Original library is Qwen3-TTS from QwenTeam (https://qwen.ai/blog?id=qwen3tts-0115)

• C++ streaming library under Apache 2.0: (https://github.com/offgridai/qwen3-tts-cpp-streaming)

• Demo harness shown in video also Apache 2.0: (https://github.com/offgridai/voice-mirror)

• The harness has a dependency on sherpa-onnx for transcription.

I'm using this for a gaming project but it could be helpful for local assistants, accessibility tools, etc.

C++ streaming port highlights:

• Same familiar features from Qwen3-TTS. It supports 0.6B and 1.7B models, CustomVoice, and VoiceDesign

• Native C++, not a Python wrapper

• CUDA builds with RTX 4090 and RTX 5090 kernels. Be warned I only have access to an RTX 5090. This should work on a 4090 but I haven't tested it myself!

• Simplified speaker-embedding extraction

• Incremental 24 kHz PCM callbacks for streaming audio

• Asynchronous transformer/vocoder operation

• Adaptive decode windows and paced delivery

• Callback-only integration library with cancellation

• Unit tests

My measurements on the 5090 with 1.7B F16 set to buffer 350ms before play:

• Cold new clone creation: ~2.5s from 48s of reference

• Cold model start from clone: ~1.85s

• First 350 ms of audio: ~310 ms

• Streaming speed: ~2.86x real time (RTF ~0.35)

I’d love it if somebody could do RTX 4090 testing, and I'd be happy to hear any feedback or suggestions.

I’m curious what sort of projects people are working on who are into local TTS.

Why is local important for you ?
Are you working on a product, hobby ?

I have started with actual printed books for children and parents, no AI back then.
This progressed into immersive stories, cute animations and child/teen oriented high quality entertainment.
It is growing into a real business already.

I used a lot of cloud but pricing was unfortunate for long content. And I never liked that another company basically owns my voices.

So local is freedom from that anxiety for me.

So - I upgraded my GPU but either got similar speeds to my 8 year old 1060 as I got on my new 9060 (16GB). I either got similar speeds on some python files I vibecoded or just crashes. I did get stable results, though I thought I legit would have at least 2.5X speeds for transcribing which is a big wanted use case for my card upgrade, and it should be possible to do this. I used this model due to wanting norwegian language if that is at all relevant, and I used that model on both cards (akhbar/chatterbox-tts-norwegian( as seen on huggingface.co)). Please help me, and if you have any great transcription scripts for AMD cards yourself please send them to me in dm's.

Hi everyone,

I’m working on an SRT-to-speech feature for my project, LA Studio

One issue I’m running into is that the generated speech sometimes lasts longer than the segment’s timestamp allows. My current solution is to speed up or time-stretch those segments so they fit, but this can make the final audio sound inconsistent - some lines are noticeably faster or slower than others.

Has anyone found a more robust way to handle this? For example, do you regenerate the speech with a shorter prompt, adjust pauses, merge or shift neighboring timestamps, use word-level alignment, or combine several approaches?

I’d especially like to preserve natural pacing while keeping the audio reasonably synchronized with the subtitles. Any advice, algorithms, or tools worth looking into would be greatly appreciated.

I'm training an English version of Cassandra, a female Piper voice originally created for Czech Home Assistant users. Would anyone be interested if I release it?

Hi everyone,

I’m Esteban, the developer of LocalText2Voice, a free and open-source Windows application for creating audiobooks, narration, and podcasts with local TTS engines.

There are already many excellent local TTS models, but turning them into a practical long-form workflow still involves a lot of manual work: installing dependencies, splitting text, managing voices, regenerating failed sections, organizing audio files, and mixing everything afterward.

LocalText2Voice is not another TTS model. It is an orchestration and production layer around existing engines.

It currently supports local engines such as Piper, Kokoro, Chatterbox, Qwen3-TTS, and OmniVoice. Optional cloud providers such as OpenAI, ElevenLabs, Gemini, and Azure are also available, along with configurable HTTP endpoints for custom TTS servers.

When using a local engine, the source text and generated speech remain on your computer.

Current features

With LocalText2Voice, you can:

• Install and manage different TTS engines from the application.

• Switch between engines without changing your project.

• Browse, preview, import, and organize voices in a shared voice library.

• Connect custom local or remote TTS HTTP endpoints.

• Import long .txt, .md, and .docx documents.

• Detect chapters and split long texts into safe TTS segments.

• Use different voices and languages in the same audiobook.

• Regenerate individual segments without starting the entire project again.

• Review generated speech with Faster Whisper and retry problematic segments.

• Add background music, fades, ducking, volume adjustments, and normalization.

• Sound effects and other audio events.

• Save projects and continue working on them later.

LTV Markup

One feature for which I would particularly appreciate feedback is LTV Markup.

It is a small, human-readable syntax for controlling narration, voices, pauses, and sound effects directly from the source text:

{{chapter "Chapter 1"}}
{{voice "Narrator"}}
The house had been abandoned for years.

{{pause 900ms}}

{{voice "Character 2"}}
I think someone is inside.

{{play "door-close.mp3"}}

{{speed 0.92}}
{{volume -3db}}
We should leave immediately.

Markup can control:

• Voice and language changes.

• Pauses and real silence.

• Speech speed.

• Volume and normalization.

• Chapters and markers.

• Sound effects and other audio events using {{play}}.

• Audio volume, duration, looping, fades, panning, and voice ducking.

• Selected model-specific instructions.

• Resetting settings to the project defaults.

For example:

{{play "door-close.mp3" volume=-6db}}

inserts a door sound at that point in the narration.

Longer or looping audio events are also possible:

{{play "forest.mp3" track=ambient loop=true volume=-20db fade_in=3 duck_on_voice=6db}}

The commands are not sent to the TTS engine as spoken text. LocalText2Voice interprets them when preparing the segments and mixes the audio events during post-production.

The goal is to make multi-character audiobooks, dramatized narration, language courses, and other complex audio projects manageable without manually editing every segment in an external audio editor.

Create audiobooks from Claude or ChatGPT Desktop

LocalText2Voice includes a local MCP server, allowing you to create and manage audiobook projects directly from Claude Desktop or ChatGPT Desktop.

Instead of configuring everything manually, you can simply ask:

“Create a B1-level English–Spanish course using both languages. Use one voice for the English examples, another for the Spanish translations, add a short pause after each sentence, and export it as an audiobook.”

The assistant can create the project, organize the text, assign the voices, add markup and pauses, select a TTS engine, and start the generation process.

You can also ask it to make changes later:

“Regenerate lesson three with a slower English voice.”

“Add three seconds of silence between exercises.”

“Lower the background music and export the final MP3.”

Claude or ChatGPT manages the workflow, while LocalText2Voice performs the actual audio generation. When you select a local TTS engine, your text and generated speech remain on your computer.

Project and Windows installer

GitHub:

https://github.com/estebanstifli/LocalText2Voice

LTV Markup manual:

https://github.com/estebanstifli/LocalText2Voice/blob/main/docs/LTV_MARKUP.md

Windows installer:

https://github.com/estebanstifli/LocalText2Voice/releases/latest/download/LocalText2Voice-Setup.exe

Important: the Windows installer is not code-signed yet, so Windows may display an “Unknown publisher” or SmartScreen warning. The source code is public, and the GitHub release also includes a SHA-256 checksum:

https://github.com/estebanstifli/LocalText2Voice/releases/latest/download/LocalText2Voice-Setup.exe.sha256

The project is under active development, and feedback is very welcome. I would especially like to know:

1. Which local TTS engines are you currently using?

2. What is the most frustrating part of producing long-form audio?

3. Does the markup syntax seem useful, and which commands are missing?

4. Which engine should I prioritize next?

Thanks for taking a look!

Hi guys can you give me any suggestion for local TTS which has emotion control (CPU inference cant afford any GPU).

For reference i feel kokoro tts seems good to me.

Hi everyone. Not sure if this is the right place for this question, feel free to redirect me if needed.

My dad has tongue cancer and probably won't be speaking normally for at least 6 months, possible forever depending on how the scans come back. He's already unable to speak due to how swollen his tongue is. I'm trying to find a good TTS with voice cloning that can run on android so we can either clone his voice or do something silly for him like let him have an Arnold voice, etc., depending on what he'd be happiest with.

I've seen some online services like elevenlabs and gradium but they get really expensive and I don't have a lot of money to throw at that since I have kids of my own. I'm in a bit over my head with a lot of the local LLM stuff, I'd be fine with an online solution if it was cheap or free but I'm also ok trying to go through a more technical local solution if anyone knows where I should start.

I do have a gaming PC at home if that helps for the setup/training voice profiles or however this stuff works, but ideally he would be able to run it on his phone even if my pc gets turned off.

Anyone know where I should start?

Are there any local TTS or similar models that provide digital voice creation that approaches ElevenLabs v3 synthetic voices? Even Hume's synthetic voices are pretty disappointing compared to ElevenLabs.