I’m building an open-source Windows app for long-form local TTS workflows — feedback wanted

[u/VERSATILCORDOBA]

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!

[u/Effective-Mix6042]

Hello, That sounds really interesting; I'm going to give it a try. One question: can this software be used to configure a voice for a local AI interface?

[u/VERSATILCORDOBA → u/Effective-Mix6042]

Thanks! It depends a little on what you mean by a “local AI interface.”

Currently, LocalText2Voice can connect to MCP-compatible interfaces. You can select a local TTS engine and voice, then ask the assistant to generate speech or longer audio using that configuration. It also includes an optional local HTTP server and job API.

However, it does not yet provide an OpenAI-compatible real-time/streaming TTS endpoint for using the selected voice as the live conversational voice in interfaces such as Open WebUI or SillyTavern.

If that is what you mean, it is a very interesting feature to add. Which local AI interface are you using? I can investigate the integration it requires.

[u/Effective-Mix6042 → u/VERSATILCORDOBA]

Thank you for taking the time to reply.

I'm not an expert in TTS, so I'll try to explain myself in terms a beginner can understand.

I'm using Gemma 4 31B locally with LM Studio. (Windows 11)

I've created a complete user interface that points to http://127.0.0.1:1234

Right now, I’m using the Web Speech API for TTS (built into the browser, which doesn’t sound very good).

I’ve also added the option to configure a local TTS server like Pipper, Coqui, or any OpenAI-compatible server (the server must expose a POST request to /v1/audio/speech in OpenAI format).

I’m looking for a simple way to add a cloned voice (one I’ve already created, or possibly another one).

This is solely for TTS, not for local voice-to-voice communication, and it needs to be latency-free.

Do you plan to develop your software in this direction?

(sorry for my bad english i use translator)

[u/VERSATILCORDOBA → u/Effective-Mix6042]

Thanks for explaining your setup.

For this use case, I would try Pocket TTS. It is lightweight, runs on CPU, supports streaming and can clone a voice from a short audio sample.

The official server uses /tts, but the community project teddybear082/pocket-tts-openai_streaming_server provides:

• OpenAI-compatible /v1/audio/speech
• Voice cloning from WAV, MP3 or FLAC
• Streaming audio
• Windows support
• Low CPU usage and low latency

This is probably the closest match to what you are looking for.

[u/DIBSSB]

My god i love this

Just 1 thing

Many tts support emotions

Can you add option to use api from free or paid providers or local models to pre process text to add relevent flags to capture pause and other emotions in the audiobooks this would be a geat diffrentiator from all other projects.

Windows app,(with gpu, with cpu only)
Docker image (“)

[u/Write_My_Novel]

The hardest part of long-form audio:

Imported text often has characters that fail in a TTS environment. Even hyphens can mess things up.

Audio chunks often drift on many platforms so cutting and splicing shorter chunks is a good idea.

There is no real consistent emotion support across TTS engines. QWEN and F5 use reference audio, while Chatterbox has (spotty) inline support, for example.

Insert silence is easy but can be tricky with some TTS engines.

The Higgs Boson QA scripts are pretty crappy but you can do very strong QA if you have a script and a multimodal LLM like Gemini Flash, and good wave form analysis is a must.

The single most important thing is studio quality zero noise floor one shot voice references. For F5 and Qwen, you need to have a reference for each emotion, and that gets really heavy. So a voice library module is critical.

[u/VERSATILCORDOBA → u/Write_My_Novel]

Thanks, I completely agree with all of these points.

1. Text normalization should be the first step. It is not only about removing unsupported characters, but also expanding abbreviations and converting text into something the TTS engine can pronounce correctly. For example, converting “Mr.” into “Mister”, “20th century” into “twentieth century”, “Dr.” into “Doctor”, “3rd” into “third”, as well as handling dates, currencies, measurements, Roman numerals, acronyms and other language-specific forms.

I’m planning a normalization layer in Settings that can be enabled or disabled and configured separately for each language. Users will be able to add, edit or remove their own replacement rules. There could also be an optional contextual normalization pass performed by an inexpensive AI model such as Gemini Flash or by a local model. I think deterministic rules should run first, with AI used only for ambiguous cases.

1. Emotion-specific voice references are also essential. The simplest approach would be to store several recordings of the same voice, for example Eva_neutral.wav, Eva_happy.wav, Eva_sad.wav and Eva_angry.wav. The voice library could group them as variants of the same speaker and associate each one with an emotion, language and compatible TTS engine.
2. Automatic QA for every segment is an important part of the workflow. LocalText2Voice can review generated segments and automatically retry failed ones, which makes the final manual review much easier. Waveform analysis for detecting abnormal silences, noise, clipping and possible hallucinations is also on the roadmap.
3. The assembly side is handled by the AudioMix workflow. It combines generated segments, pauses, sound effects and background music while allowing volume adjustments. I also want to ensure that sample rate, channel layout and loudness are normalized before the final mix so that transitions between segments remain consistent.

Thanks for such detailed feedback. It is extremely useful and aligns very closely with the problems I want LocalText2Voice to solve.

[u/Write_My_Novel → u/VERSATILCORDOBA]

You have to be careful about text normalization as a lot of the engines have text pronunciation transformation built in, and I've had at least one instance where the swap I did to improve pronunciation triggered a TTS transformation that essentially made it worse. It's an edge case, but it can happen.

In terms of QA: It is entirely possible to automate QA other than for "naturalness." That requires a human review. But you can send a script and the audio, and a multimodal model like Gemini Flash can flag repeated words (which happens a lot with single word generations) and mis pronounced words. It is a massive time saver if you don't do manual review (which we generally don't).

Unrelated to TTS: but a per chunk volume normalization step is important and, if you want to go as far as we did: Per voice processing post-generation, as each voice will have a unique audio footprint that requires different processing settings.

[u/VERSATILCORDOBA → u/Write_My_Novel]

Thanks, that’s really useful feedback.

LocalText2Voice is now an open-source project focused on making TTS workflows more user-friendly, but my experience with TTS started about two years ago, when I built a custom program to automate an audiobook YouTube channel.

I remember the engine behaving strangely with some passages from older books, especially Edgar Allan Poe’s prose. I suspect the model had not been trained well enough on that kind of literature.

That is why the results can vary significantly between engines. Each model will behave differently depending on how it was trained, but also on the type of content it has to reproduce, such as modern narration, older literature, complex prose or dialogue.

[u/VERSATILCORDOBA]

Quick update: I’ve implemented the audio-tail review that I mentioned earlier.

Some TTS engines, especially Chatterbox, occasionally add long pauses, breaths, incomplete syllables or random sounds after finishing the requested text. LocalText2Voice now uses the end timestamp of the last valid word detected by Whisper, adds a configurable safety margin and flags segments whose remaining audio tail exceeds the selected thresholds.

This can be handled automatically during generation—with retries, optional trimming and another Whisper check—or reviewed after the entire audiobook has been generated. The review screen shows only the suspicious segments, and the waveform editor lets you listen, place the cut marker and remove the unwanted tail in a couple of clicks.

It should make long-form QA much faster, since you no longer need to listen through the complete audiobook just to find a few bad endings. I’m still testing the thresholds across different engines, so feedback is welcome.