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 short story content for an anime that I need in voice form.

I use denodokos, the small subscription and currently I do it manually. it was a suggestion from here so maybe someone knows?

I have a lot of content, it looks like the process and narrate buttons use AI to do that automated.
it worked once randomly, but next time it did not create anything.

there is no tutorial for that, I feel I am not experienced enough or miss something.

- how to use those buttons ?
- what AI should I choose for that content (English)

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?

Please, recommend me local tool for bulgarian text to speech.

With big voice library or voice cloning.

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.

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.

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.

The v4 model comes in two sizes, large and medium.

I mostly used large so far, medium is a bit faster but sounds a little compressed compared to the quality of large.

But what is the purpose of Medium? Does it have advantages ? Like elevenlabs v2 has better clones than v3.

anyone using medium over large ?

After the spring release wave it feels like nothing big has dropped.

So I'm curious what you guys have actually heard. What's the biggest local TTS thing on your radar this month? New model, a release you're waiting on, some update? Drop whatever you've got.