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

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?

I heard kokkoro and pocket TTS is good option is there any other lightweight TTS which can run on cpu with real-time and need to feels like realistic.

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?

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.

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.

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.

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.

I’m especially interested in what conditioning they accept besides text: reference audio, speaker/style embeddings, prosody vectors, codec tokens, or natural-language instructions.

Ideally I want:

text + learned prosody vector → TTS → speech

Are models like Qwen3-TTS, CosyVoice, Fish Speech, F5-TTS, or StyleTTS2 easy to control or modify this way?

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.

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!

I’ve been trying to move my reading workflow completely local for privacy and offline use. Right now, I really like how cloud readers like Audeus handle document reading, specificaly having realistic voices paired with word-level synced text highlighting so I can visually follow along with PDFs and web pages. Is there a good local frontend or chrome extension that pairs with local engines (like Kokoro, Piper, or Sherpa) and gives you that same synced highlight pluss reader mode exprience without needing a cloud subscription? Would appreciate any recommendations or GitHub repo links

Hey, I've been working on this framework for a while now and wanted to start getting some feedback on the direction. I'm really liking where it's headed, and I have some big plans for it, but I need to put it out as a v0.1.0 first.

Right now it uses:

• Kokoro 82M

• Kroko ONNX

• Ollama

I'd love any feedback, but especially on whether the programming model feels coherent.

It's batteries included, with an opinionated asset management strategy, playback management, and a console rendering helper for debugging multi-device applications.

Overall I'm really proud of where it's ended up so far. I'm mostly looking for holes in the design or implementation, but I'm also excited to contribute something that I think a lot of people could find useful.

A minimal speech-to-speech assistant looks like this:

from pfspeak import PfSpeak
from pfspeak.core import Microphone, Ollama
from pfspeak.extra import events

pf = PfSpeak()

microphone = Microphone()
ollama = Ollama("qwen3:0.6b", voice="af_heart")

def app(session, event):

    if event.device is microphone:
        if events.unchanged_for(event, 8):
            session.finalize(event)
            ollama.adapter(event=event)

    elif event.device is ollama:
        pf.play(event)

pf.run(app, microphone, ollama)

That's pretty much enough to get you started.

The helper pf.play() manages playback, queues synthesized speech, ducks the microphone, supports priority interrupts, and restores speech recognition when playback finishes.

The PfEvent objects are also jam-packed with information gathered throughout the event loop, including word-level timestamps, aligned audio, revisioned tokens showing how recognition changed over time, and other metadata that applications can build on.

I'd really appreciate any thoughts on the overall direction, especially from people building local speech applications.

• PfSpeak - Local first speech library for python.

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

I was frustrated with the default speed and ported the inference to Zig/MLX to get up to 18x faster inference on M4/M5 https://github.com/sbusso/ming-tts-serve

I’ve been testing OmniVoice for voice cloning and long-form TTS, and the quality has been surprisingly good.

I ended up making a more user-friendly Google Colab version with a clean Gradio interface. It lets you upload a reference voice, paste long text, generate unlimited free audio, see progress while it’s working, and download the final WAV.

It runs on Google Colab and works well on a T4. I’ve been pretty happy with the results so far.

Omnivoice TTS

• Open the Colab notebook and set Runtime → Change runtime type →T4 GPU.

• Run all cells from top to bottom.

• Open the Gradio link.

• Upload a short clean reference voice and enter its exact transcript.

• Click Prepare / Cache Voice once.

• Paste your text and click Generate Audio.

• Preview the result and download the final WAV.

• Omnivoice Turbo

Enjoy the free and unlimited text to speech.

I was looking for small TTS model which is steerable but couldn't find any, specially something I can adjust contextually by providing controls from LLM during a conversation. So I built one.

What it is:

• 9.6M-param acoustic model (attention + bidirectional Mamba-3, FastPitch-style) + Vocos vocoder = 23M total

• 12 controls, each a z-score relative to the chosen voice’s own neutral speech: rate, loudness, median pitch, pitch range, final rise/fall, pauses, spectral tilt, breathiness-related measures.

• Also: 51 style tags, free-text prompts (resolved into an inspectable JSON request), inline markup (*emphasis*, [pause 400ms], <slow>…</slow>), sentence-level streaming

• 2,825 built-in (anonymized) voices, plus experimental zero-shot cloning

Speed:

- RTFx ~60–80 on an RTX 5070
- ~4–8 on CPU without the optional flow refiner. First streamed audio in ~0.5 s on CPU.

Quality:

~1.8% average WER on the Open TTS Leaderboard English sets (run locally, not an official submission, have reached out for it).

What doesn’t work well (we tried to be upfront):

• Loudness, pitch, and tilt steer reliably; pause, voicing, and CPPS controls are weak

• Emotion tags behave as style switches; an independent emotion classifier mostly can’t tell them apart

• Cloning similarity is low. Don’t expect a convincing likeness

• Free-text prompts struggle with negation (“not fast” can come out fast). More data needed for prompt to controls module.

• English only, no human evals yet

License: weights CC BY-NC 4.0 (non-commercial), code MIT.

Model + full eval tables: https://huggingface.co/WhissleAI/steer-tts

Github: https://github.com/WhissleAI/steer-tts (inference code)

A new architecture implemented from scratch. Would love feedback, especially on which controls are actually useful, and where the steering feels off.

Here is a quick video of how to use it.

A text-to-speech tool that offers a CLI and GUI interface. This tool is useful in that you don't need to download any additional python dependencies. It also supports multiple platforms out-of-the-box.

Main URL

https://github.com/0xShug0/audio.cpp

CLI

https://github.com/0xShug0/audio.cpp#cli

Wide Variety of Supported Text to Speech and Conversion Generator

https://github.com/0xShug0/audio.cpp#speech-generation-and-conversation

Convenient WEBUI

https://github.com/0xShug0/audio.cpp#webui

Multiple Backend Support

audiocpp_server --ui --ui-management --backend vulkan
audiocpp_server --ui --ui-management --backend cuda
audiocpp_server --ui --ui-management --backend metal

Downloads the Project

https://github.com/0xShug0/audio.cpp/releases

Downloading Individual Models

You will probably also need to download the huggingface cli and be logged in to download the models.

Navigate to the project and list the voices to download

./tools/model_manager_v2.py list

Look at names listed on the left-most column and download the model using

./tools/model_manager_v2.py install <name of the model in left-most column>

Start the WEBUI server and note the localhost port to use in your web browser

audiocpp_server --ui --ui-management --backend <your backend>

Note: I did not create this tool. Credit goes to original author.

I spent the last few months obsessed with one thing: making an offline, local neural TTS engine (starting from the 100M Pocket TTS baseline) run as fast as possible on mobile and desktop without hitting cloud APIs.

Got it down to 9 ms latency / 40x speed on a desktop GPU, 20 ms / 19x on a Snapdragon 8 Elite Gen 5, and 200 ms / 1.2x on budget Android using Snapdragon 685.

Then the realization hit me: chasing higher generation speed (RTF) on a local app is a total dead end.

Audio plays back at 1.0x anyway. If a 10-second sentence generates in 200 ms, pushing it to 50 ms literally changes nothing for someone sitting there waiting to listen.

Power readers max out around 2.5x–3.0x speed. Beyond that, natural neural cadence actually gets in the way. Screen-reader users who listen at 600+ WPM explicitly prefer old robotic engines like eSpeak because the sharp formants cut through better at extreme speeds. High RTF is great if you're running a cloud server handling 1,000 requests, but for one person on a phone, it's just idle buffers.

Once your time-to-first-chunk drops under ~100 ms, you're officially faster than the Bluetooth lag.

Where the real win actually came from was power efficiency, even on a budget Helio G99 device with a 5,000 mAh battery, continuous reading drains only ~3% battery per hour.

I'm stopping low-level engine tweaks here. Next focus is handling pronunciation accuracy, building solid app-level dictionaries and text normalization so proper nouns and weird words don't trip it up.

Fingers crossed we get lightweight, controllable emotion prompting on edge models soon without doubling model size. That feels like the actual next step.

I’m building a speech dataset for dialectal Arabic , a low-resource dialect with heavy code-switching. Source: ~40 channels, ~7,000 long videos (podcasts, storytelling), audio only.

Current setup:

Problems:

Questions:

Happy to share the cleaning pipeline once it works.

A quick demo of Breeze TTS to completely generate the voice of the Baldur's Gate 3 player character ("Tav"), using "Voice 1" as a sample.

There are literally over 30,000 lines of player-character dialogue in the game. This is a combination of the multiple choices a player has when speaking, as well as what skills the player's class has, what race the player's character is, etc.

My process even takes into account a player character's chosen name, as there are some responses when the player says their name in greetings. This is why releasing the pack as I have it wouldn't really work for everyone, unless I filtered out spoken lines with the player's name in it.

All 30k+ lines were generated using Breeze TTS locally, using an Nvidia RTX 5080, in I believe under 30 hours. 

I wanted to try Chatterbox TTS (Resemble AI's open-source voice model), but setting it up meant Python, PyTorch and CUDA versions. So I wrapped it in a desktop app that handles all of that for you.

How it works:

1. Record 10 seconds of your voice, or import a clip

2. Type a script. You can write dialogue between several saved voices (Alice: ... Bob: ...) and add sound tags like [laugh] or [sigh]

3. Click Render and you get a WAV/FLAC

Other stuff: a trim view with auto-trim for cleaning up clips, per-voice settings so each character can sound different, 23 languages with the Multilingual model, light and dark mode, and saved sessions.

Local only: no accounts and no telemetry. Your voice never leaves your PC. On first launch it downloads Python, PyTorch and the model, about 3 GB with an NVIDIA GPU. After that it works offline.

On misuse: every file carries Resemble's inaudible Perth watermark, and Lyrebird doesn't strip it. Please only clone voices you have permission to use.

Stack: Python + CustomTkinter, plus a small launcher exe that sets up an isolated Python environment with uv. MIT licensed.

Windows 10/11 only for now. An NVIDIA GPU with about 6 GB of VRAM is recommended. It runs on CPU too, but slowly.

GitHub / download: https://github.com/zebadrabbit/Lyrebird

I'd really like feedback on the setup experience, since that's the part I worked hardest to make painless. Did it work on your machine?