Free, open-source AI production for long-form audio and video.
Turn books, lessons, articles, notes, and scripts into audiobooks, podcasts, documentaries, films, and animated videos.

Download Windows installer · Markup manual · AndromedaNova.com

LocalText2Voice is a free desktop app for long-form AI voice and video production. It can run fully local and offline for narration with engines such as Piper, Kokoro, Chatterbox, Qwen3 TTS, OmniVoice, IndexTTS-2.5, and the optional non-commercial F5-TTS Russian engine, while also supporting optional cloud APIs such as OpenAI TTS, ElevenLabs, Google Gemini TTS, Azure Speech, and direct video providers.

The workflow is designed for long projects: import or write a script, generate narration, review and correct segments, build an audio mix, then use Video Storyboard to plan scenes, generate visuals, assemble motion, and render a long-form MP4. Local engines keep data on the user's computer; cloud providers are optional and clearly configured.

• Optional audio.cpp engines: Higgs Audio v3 TTS 4B Q8, Fish Audio S2 Pro Q8, Breeze TTS 2 Q8 and VoxCPM 2 (Q8, BF16 or Original GGUF) use a shared native runtime, with CPU, CUDA or Vulkan packages on Windows. Runtime and model weights are downloaded on demand, not bundled in the installer.

• A growing native catalog: audio.cpp is the direction for adding more local models. Each addition will be integrated and tested; upstream models do not automatically become available. Existing Python engines and cloud providers remain.

• Native expression controls: Higgs and Fish menus insert their own emotion, style, prosody and vocal tags. Breeze sends emotion instructions separately and keeps vocal events such as (laugh) in the text. Catalog references with transcripts can be reused.

• Voice design and reuse: Breeze and VoxCPM can design a voice from a description; preview and save its recording with the transcript. Local reference recordings are shared across compatible cloning engines. VoxCPM direction is applied to every chunk, with guidance and diffusion controls available in the UI and MCP.

• Per-segment editing: Review now lets you change a segment's text, reference voice and synthesis parameters without changing global settings. Regenerate and approve the replacement before rebuilding the audiobook.

• MCP integration: select the native model/backend and pass reference audio and transcript through existing generation tools; EngineHost keeps the model loaded.

• Chatterbox Turbo markup: choose emotion/style tags and inline vocal events such as {{vocal laugh}} or {{vocal sigh}} from the editor. These controls are for Turbo's English model; intensity and Custom descriptions remain IndexTTS features.

• Qwen Base voice references: reuse compatible catalog recordings with their transcripts, keeping cloned references separate from CustomVoice preset speakers.

• Project folders that follow their names: rename a project and its folder together, with collision protection, updated asset paths and interruption recovery. Export to a project-relative folder or a fixed absolute location.

• More reliable long projects: safer WAV replacement, fewer Windows playback file locks, background cache statistics and smoother project loading/highlighting.

• Signed Windows distribution: the 3.0.0 installer, uninstaller, application, Engine Host and MCP executable carry verified production Certum signatures with SHA-256 and RFC 3161 timestamps. Publisher: ESTEBAN GARCIA PEREZ.

See the 3.0.0 release notes, audio.cpp guide and full changelog. The changes prepared locally as 2.3.0 are included in 3.0.0; 2.3.0 was not published.

Clone a voice from a reference recording and direct each passage with IndexTTS-2.5, including Spanish narration and CUDA/BF16 inference. Install the optional engine in Settings → TTS Engines; compatible WAV references from the voice catalog can be reused.

The editor's emotion button offers eight presets, Off, and Custom:

{{lang en}}
{{voice "Teacher"}}
{{emotion happy 90%}}
We did it! At last, we can celebrate together.
{{emotion custom "Friendly and energetic" 90%}}
Today we are going to discover something amazing. Join me on this new adventure.
{{emotion off}}
This passage keeps the emotion of the reference voice.

Presets use fixed vectors without loading QwenEmotion. Custom descriptions are resolved together before narration: QwenEmotion loads once for missing descriptions, then exits before IndexTTS loads. The resulting vectors are saved with the segments and reused when regenerating them. Emotions are optional; without a local or general instruction, narration uses the reference voice's emotion.

Choose emotions in the text editor's Emotion → IndexTTS menu. Emotion → Chatterbox also offers Turbo's ten emotion/style tags and nine inline vocal events ({{vocal laugh}}, {{vocal sigh}}, and more). Turbo requires English and uses native tags without a QwenEmotion preparation stage; emotion percentages and Custom descriptions remain IndexTTS features. Choosing a submenu does not switch engines. IndexTTS settings contain voice, language and runtime options, with synthesis tuning under Advanced settings; emotion controls and sample testing live in the editor workflow.

See the emotion markup guide and IndexTTS setup, parameters and license. The optional model has its own bilibili license and conditions.

IndexTTS support was introduced in 2.2.0, alongside fixes for very short Chatterbox inputs, character-based estimates and configurable Qwen/Chatterbox chunk packing.

Optional audio.cpp integration supports native Higgs Audio v3 TTS 4B Q8, Fish Audio S2 Pro Q8, Breeze TTS 2 Q8 and VoxCPM 2 (Q8, BF16 or Original GGUF) inference, downloadable from TTS settings. See the setup and testing guide (Spanish) for requirements, model licenses, MCP parameters and first-delivery limits.

LocalText2Voice has grown from a local long-form audio tool into a complete audio-to-video workflow. You can still create only narration, audiobooks and podcasts, or continue through Video Storyboard to produce documentaries, films, illustrated lessons and animated stories. Every project remains editable and human review is part of the workflow before final export.

From Text to AI Documentary: A Complete Workflow with LocalText2Voice Complete tutorial: from source text to reviewed documentary.	From Text to a 14-Minute AI Documentary | GPT Image 2 + Wan 2.6 Flash A complete documentary produced as video.
Jack and the Beanstalk – AI Animated Story | VideoStoryboard Demo A 3D cartoon-style storyboard demonstration.	From Bible Text to an 18-Minute AI Video | LocalText2Voice Demo From biblical source text to a long-form narrated video.

Beta feature introduced in LocalText2Voice 2.0.1 and expanded in 2.1.2.

Turn narration into an editable visual timeline, analyze scenes and reusable entities, generate or import images, create video clips, and render an MP4 with the narration audio. The 2.1.0 workflow adds richer character, location, era and object context, reference-aware prompts, batch video generation, recovery for long-running jobs, and direct video API adapters alongside ComfyUI and Runpod. Version 2.1.1 adds source-aware analysis safeguards, manual timed-prompt import, resumable work and clearer controls for long projects. This remains a beta: AI continuity, timing and generated media still need human review.

50 AI Image Styles for Video Storyboards | VideoStoryboard Demo

Explore the 50 built-in image styles, each with a preview, or create your own style prompt. Click the demo above to watch on YouTube.

Feature guide and development notes · Guía en español · Official YouTube channel

LocalText2Voice can run on modest computers, but its actual requirements depend on the local TTS model, text length, optional transcript verification, and audio processing features you use. These profiles are practical recommendations, not strict compatibility limits:

Supported platforms:

• Windows 10 or 11, 64-bit: the Windows installer is the recommended and fully packaged distribution.
• Linux, 64-bit: currently runs from source and requires Python 3.10+ with virtual-environment support and FFmpeg in PATH. The documented Linux workflow has been tested on Arch/CachyOS with KDE Plasma and Wayland.
• macOS: not currently tested or officially supported.

An NVIDIA GPU is optional. Most local engines can fall back to CPU execution, but generation may be considerably slower. GPU acceleration currently focuses on NVIDIA CUDA; other GPU families should not be assumed to accelerate every engine. Disk usage also grows with each optional engine because models and isolated dependencies, including PyTorch runtimes, are downloaded on demand. Generated projects and exported audio require additional space beyond the figures above.

See the complete release history in the changelog.

Resumen en español: LocalText2Voice es una aplicación gratuita y open source para convertir libros, cursos y textos largos en audiolibros o podcasts M4B, MP3, M4A, Opus, FLAC u OGG usando IA de voz. Puede funcionar 100% local/offline con modelos descargables, sin suscripciones ni enviar tus textos a la nube. Las APIs externas son opcionales.

• Free local workflow: no subscription is required for local TTS engines.
• Privacy-first: with local engines, your texts and generated audio stay on your PC.
• Works on normal computers: Piper and Kokoro can run without a powerful GPU.
• Scales up on strong PCs: Chatterbox, Qwen3 TTS, OmniVoice, and F5-TTS Russian can use a selected NVIDIA CUDA GPU when available.
• Long-form first: built for chapters, lessons, audiobooks, courses, and large documents.
• Review loop included: optional Faster Whisper verification compares generated audio against the original text.
• Podcast-ready: export clean narration and then create an Audio Mix with background music.
• Extensible AI architecture: local engines and cloud providers are isolated from the UI.

Watch the review on YouTube (in Russian, with the option to dub it into English).

LocalText2Voice is no longer just text to speech. It is becoming a complete long-form audio and video production pipeline for audiobooks, podcasts, documentaries, films, illustrated lessons and animated stories.

flowchart TD
    A["1. Input text<br>Paste text or import TXT / MD / DOCX / EPUB"] --> B["2. Optional normalization<br>Dictionaries and structured-value rules"]
    B --> C["3. Smart text processing<br>Paragraphs, chapters, safe chunks"]
    C --> D["4. Optional LTV Markup<br>{{voice}}, {{pause}}, {{speed}}, {{volume}}, {{cmd}}"]
    D --> E["5. TTS generation by segments<br>Piper, Kokoro, Chatterbox, Qwen3, OmniVoice, F5, or API"]
    E --> F["6. Clean narration<br>M4B, MP3, M4A, Opus, FLAC, or OGG"]
    F --> G["7. Optional Whisper review<br>Transcript, similarity, tail analysis, retries"]
    G --> H["8. Manual or automatic fixes<br>Edit, regenerate, trim, approve, rebuild"]
    H --> I["9. Timed subtitles<br>SRT and karaoke-style ASS"]
    I --> J["10. Audio Mix<br>Music, volume, fades, ducking, normalization"]
    J --> K["11. Export<br>One audio file, optional mix, subtitles, project data"]

LocalText2Voice supports multiple voice generation engines through a modular TTS architecture.

The base app stays lightweight. Heavy models and isolated Python dependencies are installed on demand into local application storage.

The audio.cpp models share a native runtime, with CPU, CUDA and Vulkan packages available on Windows. Runtime and GGUF downloads are optional and managed from Settings > TTS Engines. See the audio.cpp guide for setup, reference-voice requirements, platform limits and each model's license terms.

F5-TTS Russian is never included in the base installation. When the user accepts its non-commercial license and installs the engine, LocalText2Voice creates a separate runtime containing F5-TTS and Silero Stress and downloads F5TTS_v1_Base_v2. Silero Stress is not installed or loaded for any other engine; inside F5 it is loaded only when automatic Russian stress marks are enabled. A clean 3–12 second Russian reference recording and its exact transcript are required, avoiding an extra automatic-speech-recognition model. Manual stress marks can be preserved with + immediately before the stressed vowel. RuAccent is not installed: its public repositories currently expose conflicting license declarations, so the integration uses the clearly MIT licensed Silero Stress path instead.

Qwen3 TTS exposes two independently downloadable checkpoints in Settings:

• CustomVoice 0.6B is the faster option with nine built-in speakers.
• Base 1.7B performs full ICL voice cloning from a clean reference recording and its exact transcript. It preserves the reference timbre and expression. Natural-language style or emotion instructions on Base are experimental and are only passed through the accelerated CUDA backend; CPU generation clones the expression present in the reference audio.

• Manage voices from the selected engine.
• Preview available voice samples instantly before installing when the catalog provides audio.
• Sync the external voice catalog from LocalText2Voice-VoiceGallery.
• Store voice catalog metadata in a local SQLite cache for fast browsing.
• Download only the reference voices you want into the user app data folder.
• Download Piper voices directly from the app.
• Clone Chatterbox, OmniVoice, or F5-TTS Russian voices from uploaded audio, a selectable microphone, or a selectable system-audio loopback source.
• Record a recommended 12-second sample directly in the cloning dialog and, when Faster Whisper is installed, optionally generate its transcript locally.
• Select the default voice for generation.
• Use flexible voice matching in markup, so {{voice "edu"}} can select a longer voice name such as Eduardo - es.

• Paste long text directly into the editor.
• Import .txt, .md, .docx, and DRM-free .epub books. See the EPUB import guide for metadata, chapters and export options.
• Detect chapters, lessons, modules, Markdown headings, and uppercase short headings.
• Split text into safe TTS chunks.
• Preserve paragraph boundaries.
• Add natural paragraph pauses with randomized ranges.
• Use shorter sentence-aware chunks for engines that behave better with compact prompts.

LTV Markup lets you control narration from inside the source text:

{{chapter "Lesson 1"}}
{{voice "Serena - Spanish"}}
Bienvenido a esta lección.

{{pause 900ms}}
{{voice "Sohee - English"}}
Now listen to the same idea in English.

{{speed 0.92}}
{{volume 80%}}
This part is slower and softer.

Supported commands include:

• {{voice "..."}}
• {{lang es}}
• {{pause 700ms}}
• {{speed 0.9}}
• {{volume 0.8}}, {{volume -3db}}, {{volume.normalize -16}}
• {{cmd "..."}} for selected model-specific instructions
• {{reset}}

The editor includes optional syntax highlighting, contextual help, and a removable Markup Toolbar.

Full manual: docs/LTV_MARKUP.md

Technical addon roadmap: docs/ARCHITECTURE_ADDONS.md

Voice gallery architecture: docs/VOICE_GALLERY.md

Optional text normalization prepares a pronunciation-friendly copy before generation without changing the source text. Settings includes editable SQLite-backed starter dictionaries for Arabic, Chinese, English, French, German, Hindi, Italian, Japanese, Portuguese, Russian, and Spanish. Russian normalization includes numbers, ordinals, percentages, ruble amounts, common abbreviations, and units. When Russian is selected, the user can explicitly install the optional shared Silero Stress runtime from this tab; it runs after the generic rules, restores Ё, and is shown in the Normalized preview. F5-TTS Russian receives Silero's + stress notation, while other engines receive the safe spelling with Ё only. Dictionaries can be created, reset, enabled entry by entry, and imported or exported as JSON for external editing. Automatic rules have a global switch and individual controls for numbers, ordinals, dates, currencies, percentages, measurements, and Roman numerals. Disabling automatic rules does not disable dictionary replacements.

Optional Faster Whisper review can validate generated segments:

• Transcribes each generated WAV segment.
• Compares transcript against the original text.
• When text normalization is enabled, normalizes both comparison inputs in memory while preserving Whisper's raw transcript and word timestamps for review and subtitles.
• Calculates similarity, WER, and CER.
• Marks segments as approved, needs review, or needs retry.
• Optionally measures unexplained audio after the last source-aligned Whisper word, with configurable safety, warning, and retry thresholds.
• Supports automatic retry loops.
• Keeps the best combined transcript/tail candidate when multiple retries are attempted.
• Can conservatively trim excessive tails, re-run Whisper, and accept the trimmed candidate only when it reviews better.
• Allows manual segment editing, regeneration, preview, approve/discard, and rebuild.
• Stores word-level timestamps from Whisper for future subtitles, video sync, music cues, and sound effect synchronization.

This makes LocalText2Voice useful not only for quick TTS, but also for quality-controlled audiobook production.

When Faster Whisper word timestamps are available, LocalText2Voice creates subtitle sidecars next to each finished audio file:

• Standard .srt subtitles grouped into readable cues.
• Karaoke-style .ass subtitles with word-level timing.
• Correct offsets for podcast mixes whose narration starts after a music intro.
• Sidecars that follow the selected M4B, MP3, M4A, Opus, FLAC, or OGG output.

Subtitle export is refreshed after verification, segment regeneration, tail correction, and audiobook rebuilds.

After generating clean narration, the Audio Mix page lets you produce a podcast-style version:

• Keep the clean narration file untouched.
• Choose default background music from the Music Library.
• Preview voice, music, and mix waveforms.
• Play the mixed preview from the cursor or from the start.
• Render a full mix without running TTS again.
• Set voice volume and music volume in dB.
• Add voice start offset for music-only intro time.
• Add music tail after the voice ends.
• Configure fade in and fade out.
• Enable ducking so music drops while narration is speaking.
• Normalize final mix to podcast-friendly loudness.
• Open the output folder directly when rendering finishes.

• Store MP3/WAV music files under music/background/.
• Play, stop, rename, remove, and select default music from the UI.
• The app can ship with default music tracks.
• The selected default music is used by Audio Mix.

LocalText2Voice stores project data in SQLite and a portable project manifest:

• Audiobook/project metadata.
• Inline project names (Project1, Project2, ... by default) also rename the containing folder using a filesystem-safe name. Existing folders are never overwritten: duplicate names receive a numbered suffix. To synchronize an older folder with its current title, edit the title and press Enter without changing it. Renaming requires idle project tasks and preserves project identity, internal asset paths and unsaved editor text, with recovery after interruption. Jobs for other projects and queued items in paused batches do not block the rename.
• New path consumers can use store.project_paths(project_id) to resolve relative resources against the current directory in SQLite. This resolver follows renames without caching the folder name; external absolute paths remain supported. Legacy absolute references are still remapped during rename for compatibility.
• Settings > General > Output folder mode selects a project-relative folder (default: exports) or an absolute folder. Both are editable; browsing outside the project switches to absolute mode. Existing external output locations are preserved when opening older projects. The separate “Save audio next to the imported document” option takes precedence during narration generation when enabled.
• M4B book metadata, cover art, and named chapter markers; metadata/cover changes can be applied without rerunning TTS.
• Automatic generated covers or normalized custom cover images, including per-book cover selection in Bulk Audiobooks.
• Source text.
• Segment list.
• Segment WAV paths.
• Voice/language/config per segment.
• Review transcript and similarity metrics.
• Word-level Whisper timestamps and review/tail metrics as JSON.
• Rebuild state for edited or regenerated segments.

This prepares the project for future features such as video generation, richer sound-effect timelines, visual scenes, and advanced postproduction.

LocalText2Voice itself is free and open source under the MIT License.

The local workflow can be free to run:

• Piper local voices: free/offline, depending on each model license.
• Kokoro local models: downloaded on demand, license depends on the model.
• Chatterbox and Qwen local engines: free to run locally when installed, subject to their upstream licenses and hardware requirements.
• OmniVoice: optional and local; its code is Apache 2.0, while the pretrained model is licensed CC-BY-NC by its authors.
• F5-TTS Russian: optional and local, but its model and generated output are restricted to non-commercial use under CC BY-NC 4.0. It is attributed to Misha24-10 and is based on F5-TTS by SWivid.
• FFmpeg: bundled or local, subject to FFmpeg licensing.

Cloud APIs are optional and may be paid:

• OpenAI TTS
• ElevenLabs
• Google Gemini TTS
• Azure Speech

You choose the engine. The app does not force subscriptions.

1. Open the latest release.
2. Download LocalText2Voice-Setup.exe.
3. Run the installer.
4. Choose the application folder and the storage location for large AI assets. By default, an installation in D:\LocalText2Voice stores them under D:\LocalText2Voice\data.
5. Choose the setup profile:
   • CPU light: fast offline Piper workflow.
   • Powerful GPU: prepares OmniVoice and Faster Whisper on first launch.
6. Open Settings > TTS Engines and choose or install an engine.
7. For Piper, open Voices or Manage voices and download a voice.
8. Paste or import text.
9. Click Generate Audio.
10. Review segments if Whisper review is enabled.
11. Open Audio Mix to create the podcast version.

The Windows installer is the recommended distribution artifact. Downloadable models, isolated engine dependencies, fallback Python runtimes, voice-gallery files, and caches share one managed data tree. Its location can be moved later from Settings > General > AI model storage, including between drives, without moving projects or exported audio.

Installed Windows builds check the latest stable GitHub Release at most once every 24 hours. You can also run a check at any time from Help > Check for updates. Before an installer can be opened, both LocalText2Voice-Setup.exe and LocalText2Voice-Setup.exe.sha256 are downloaded and the SHA-256 checksum must match.

Code-signing note: the 3.0.0 Windows installer and project executables are signed with the maintainer's production Certum certificate, using SHA-256 and RFC 3161 timestamps. Publisher: ESTEBAN GARCIA PEREZ. Existing unsigned packages have not been retroactively signed, and a valid signature does not guarantee the absence of SmartScreen/antivirus warnings. The old SignPath test workflow is retired. Download public builds only from the official releases. See local Windows signing.

Linux currently runs from source. Install Python, virtual-environment support, Git, and FFmpeg first.

Debian or Ubuntu:

sudo apt update
sudo apt install python3 python3-venv ffmpeg git

Arch Linux:

sudo pacman -S python ffmpeg git

Then clone and start LocalText2Voice:

git clone https://github.com/estebanstifli/LocalText2Voice.git
cd LocalText2Voice
chmod +x run_dev.sh
./run_dev.sh

The launcher creates .venv, installs the Python requirements, selects Wayland when available, and starts the desktop application. For Piper, place the Linux piper executable in engines/piper/ or make it available through PATH; Linux executables do not use the .exe suffix. FFmpeg is discovered through PATH. Optional Python TTS engines can then be installed from the application.

See the complete Linux guide for manual startup, desktop integration, tests, and platform notes.

LocalText2Voice is an applied AI engineering project focused on productizing voice models into a real desktop workflow.

• Multi-engine TTS abstraction through BaseTTSEngine.
• Local model lifecycle management: install, validate, remove, cache, and run.
• Persistent Python workers for heavy local models to avoid reloading on every segment.
• Embedded Python runtime for optional engines without requiring users to install Python globally.
• External voice gallery with JSON indexes, SQLite cache, remote previews, and per-voice downloads.
• CUDA/CPU auto-selection where supported.
• Long-form text chunking and chapter-aware preprocessing.
• Custom markup language for voice, language, pauses, speed, volume, and model instructions.
• Faster Whisper verification pipeline with similarity scoring and retry logic.
• SQLite persistence for projects, segments, transcripts, review status, and word timestamps.
• FFmpeg audio DSP pipeline for joining, multi-format encoding, speed/volume postprocessing, loudnorm, fades, ducking, and podcast mixing.
• Local MCP stdio server for automation from local AI clients and agent tools.
• PySide6 desktop UI with background workers, progress, cancellation, logs, translation files, and portable packaging.

LocalText2Voice/
|-- main.py
|-- app/
|   |-- core/          # Text processing, markup, audio pipeline, projects, SQLite store
|   |-- tts/           # TTS engines, managers, voice catalogs, local/API providers
|   |-- verification/  # Faster Whisper runtime and persistent verifier
|   |-- server/        # Internal FastAPI service and job queue
|   |-- ui/            # PySide6 windows, pages, Audio Mix, widgets
|   |-- workers/       # Background generation, install, verification workers
|   |-- utils/         # Paths, FFmpeg, GPU detection, logging
|   `-- llm/           # Future LLM provider interface
|-- docs/
|-- locales/           # JSON UI translations
|-- engines/piper/     # Portable Piper runtime
|-- voices/            # Piper voice models
|-- music/background/  # Music library
|-- ffmpeg/            # Portable FFmpeg
|-- runtimes/          # Embedded Python runtime in portable builds
|-- tests/
`-- output/

Voice previews and downloadable reference voices live outside the main code repository in LocalText2Voice-VoiceGallery. The desktop app syncs that JSON catalog into a local SQLite cache and downloads audio assets on demand.

LocalText2Voice can be automated from local AI clients through MCP.

For Claude Desktop, Codex, ChatGPT Desktop, and other clients that launch local MCP servers through stdio, use:

mcp_stdio_bridge.py

The stdio bridge starts or reuses the persistent LocalText2Voice EngineHost. The desktop UI and MCP clients therefore share the same generation queue and the same loaded TTS model in RAM/VRAM. Saved UI settings are reloaded before every external job and act as defaults unless a tool argument overrides them. This includes the selected engine and voice, output, audio parameters, music, and automatic Faster Whisper review settings.

It exposes:

• server_info
• list_engines
• list_voices
• list_background_music
• create_audiobook
• generate_audio
• get_jobs
• get_job
• read_job_source
• write_job_source
• search_job_source
• edit_job_source
• replace_job_source_text
• cancel_job
• preload_engine
• unload_engine
• engine_memory
• get_markup_help

Example claude_desktop_config.json for a source checkout:

{
  "mcpServers": {
    "localtext2voice": {
      "command": "C:\\prueba\\ai_podcasts\\course_to_podcast\\.venv\\Scripts\\python.exe",
      "args": [
        "C:\\prueba\\ai_podcasts\\course_to_podcast\\mcp_stdio_bridge.py"
      ],
      "cwd": "C:\\prueba\\ai_podcasts\\course_to_podcast"
    }
  }
}

Example ~/.codex/config.toml for Codex or ChatGPT Desktop:

[mcp_servers.localtext2voice]
command = 'C:\prueba\ai_podcasts\course_to_podcast\.venv\Scripts\python.exe'
args = ['C:\prueba\ai_podcasts\course_to_podcast\mcp_stdio_bridge.py']
cwd = 'C:\prueba\ai_podcasts\course_to_podcast'

The Windows app generates both configurations with the correct installation and user paths under Settings -> Local Server, with buttons to copy each block and open the corresponding client configuration file.

Test with MCP Inspector:

npx @modelcontextprotocol/inspector C:\prueba\ai_podcasts\course_to_podcast\.venv\Scripts\python.exe C:\prueba\ai_podcasts\course_to_podcast\mcp_stdio_bridge.py

Start with server_info, list_engines, list_voices, and list_background_music. Then test create_audiobook with a short text and poll get_job until it completes.

Completed jobs expose an editable LocalText2Voice project. Use read_job_source to read source.txt in character-based pages, or set read_all=true for sources up to 200,000 characters. Large books should be processed with page, page_size_chars, and page_count; search results also paginate with result_offset. Mutating tools accept expected_sha256 from a prior read/search so concurrent clients cannot silently overwrite each other. Source edits keep SQLite, source.txt, and the project manifest synchronized. Existing MP3 files are retained, and the tool response reports render_required=true when the edited source needs a new render.

The stdio server exposes 57 storyboard tools (76 total with the existing audio tools). Use sb_get_timed_text to read narration timings, then let the connected agent write the scenes and prompts. No internal narrative analysis is required. sb_list_styles lists all image styles; sb_set_style selects a preset or custom style for the project or individual scenes. Entity/state references, frames, clips, image editing, preview and final MP4 rendering work without the desktop UI. See the complete workflow and tool contracts.

MCP is exposed only through stdio. The former /mcp HTTP transport has been removed. The internal FastAPI service remains because both the desktop app and stdio bridge use it. It binds to 127.0.0.1 by default.

• Health: GET /health
• Voices: GET /voices
• Jobs: POST /jobs, GET /jobs/{job_id}, POST /jobs/{job_id}/cancel
• Job source: GET/PUT /jobs/{job_id}/source
• Source operations: POST /jobs/{job_id}/source/search, /edit, /replace
• Storyboard operations: POST /storyboard/{sb_tool_name} with tool arguments as JSON.

Configured Bearer authentication also protects storyboard operations. Restart an idle EngineHost after upgrading so it loads the new routes. Do not stop a host with active jobs; the shutdown endpoint rejects active storyboard work.

Python 3.10 or newer is recommended:

git clone https://github.com/estebanstifli/LocalText2Voice.git
cd LocalText2Voice
py -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
python -m pip install -r requirements.txt
python main.py

For faster local testing without rebuilding the EXE:

run_dev.bat

The repository does not include large third-party models. Use the UI installers or place runtime files manually when needed.

build_windows.bat

The build creates a portable folder under:

dist/LocalText2Voice/
|-- LocalText2Voice.exe
|-- engines/
|-- voices/
|-- ffmpeg/
|-- music/
|-- output/
|-- licenses/
|-- runtimes/python311/
|-- config.example.json
|-- LICENSE
`-- THIRD_PARTY_NOTICES.md

Large models and optional engine dependencies should stay outside the main executable and be downloaded on demand.

The tracked Inno Setup definition is installer/LocalText2Voice.iss. It is built from the portable dist/LocalText2Voice/ folder using the local compiler in .util_instalador_y_firmas/, which remains ignored because it may contain signing tools and temporary artifacts.

.\tools\build_windows_installer.ps1

The generated installer is:

.util_instalador_y_firmas/output/LocalText2Voice-Setup.exe
.util_instalador_y_firmas/output/LocalText2Voice-Setup.exe.sha256

Installer details, first-run GPU setup behavior, validation notes, and future signing plan are documented in docs/WINDOWS_INSTALLER_AND_SIGNING.md.

The app creates config.json automatically if it does not exist.

Important settings include:

• Selected TTS engine.
• Output folder.
• UI language.
• Markup Toolbar visibility.
• Editor syntax highlighting.
• Default voice.
• Default music.
• Paragraph pause rules.
• Review/Faster Whisper settings.
• Audio Mix settings.
• API credentials for optional cloud providers.

The UI is designed for translation through JSON locale files.

Current languages:

• English
• Spanish
• French
• German
• Italian
• Portuguese
• Simplified Chinese
• Japanese
• Arabic
• Hindi
• Russian

text-to-speech, tts, ai-voice, offline-tts, local-ai, piper-tts, kokoro-tts, chatterbox-tts, qwen-tts, faster-whisper, audiobook, podcast, video-generation, video-storyboard, documentary, animated-video, comfyui, runpod, mp3, python, pyside6, ffmpeg, open-source, education, course-generator, voice-ai, speech-synthesis

Recommended GitHub topics:

text-to-speech
tts
ai-voice
offline-tts
local-ai
piper
kokoro
chatterbox
qwen
faster-whisper
podcast
audiobook
video-generation
video-storyboard
documentary
animated-video
comfyui
runpod
mp3
python
pyside6
ffmpeg
open-source
education
ai-tools
course-generator

• Offline Piper TTS generation.
• Voice manager with download and preview.
• Multiple local engines: Piper, Kokoro, Chatterbox, Qwen3 TTS, OmniVoice, F5-TTS Russian.
• External voice gallery repository with previews and per-voice install flow.
• Optional cloud engines: OpenAI, ElevenLabs, Gemini, Azure.
• Audio Mix page with waveform preview and full mix render.
• Custom LTV Markup.
• Faster Whisper review and segment similarity scoring.
• SQLite project/segment persistence.
• Word-level timestamps for future subtitle and timeline features.
• Sound effects and music timeline commands from markup.
• SRT and karaoke-style ASS subtitle export from Whisper timestamps.
• Video Storyboard beta with scene analysis, visual references, timeline editing, and MP4 rendering.
• Video/audio cover workflow.
• Windows installer with CPU/GPU setup profiles.
• Automatic update system with SHA-256 verification.
• Signed Windows installer.
• Linux source workflow.
• Native macOS/Linux packaging.
• Optional LLM-assisted course/script generation.

python -m pytest -q

The tests cover text processing, markup parsing, audio pipeline behavior, review storage, i18n, engine managers, and UI structure. Real synthesis requires the relevant external models/runtimes.

Issues, feature ideas, translations, docs, and pull requests are welcome.

Please do not commit:

• Large model files.
• API keys.
• Generated build folders.
• Copyrighted music or voice assets without permission.

Read CONTRIBUTING.md before submitting changes.

Special thanks to Roman Kudryavsky (devpilgrin) for contributing, testing, and documenting the Linux version of LocalText2Voice.

Special thanks also to Eugene Schelakov for his help with the Russian localization of the LocalText2Voice user interface and for creating a detailed video about the project for the Russian-speaking community.

Special thanks to audio.cpp and its contributors for the shared native runtime that powers our Higgs Audio v3, Fish Audio S2 Pro, Breeze TTS 2 and VoxCPM 2 integration.

LocalText2Voice is possible because researchers, open-source maintainers, model authors, and commercial voice providers have made strong speech technology available to developers. Thank you to the following upstream projects and teams:

LocalText2Voice is an independent project and is not endorsed by these upstream projects or providers. Each engine, model, voice, dataset, and API remains subject to its own license and terms. See THIRD_PARTY_NOTICES.md before redistribution or commercial use.

LocalText2Voice source code is released under the MIT License.

Third-party engines, models, voices, FFmpeg, Qt/PySide6, music files, and API providers keep their own licenses. Always check model cards and redistribution terms before publishing a packaged build.

Windows signing uses Certum SimplySign and Microsoft SignTool locally. See our Code signing policy. Each signed package requires verification; existing unsigned installers have not been retroactively signed.

design_voice(name, description, language, engine_id="audiocpp", model=None, sample_text=None, idempotency_key=None, wait_until_complete=True, wait_timeout_seconds=60) submits a server job that generates, verifies and saves a reusable voice. get_voice(voice_id) returns the catalog record, audio URI, reference transcript and verification metadata. No separate save tool is needed.

Supported design engines are OmniVoice and audio.cpp Breeze TTS 2 / VoxCPM 2. The default model is voxcpm2_q8_0; OmniVoice uses model="omnivoice". Both the selected TTS model and Faster Whisper small must already be installed. list_engines advertises the supported design models and verification languages. Breeze supports English and Chinese. A missing sample uses a versioned template for es, en or zh; other languages require explicit sample text (up to 600 characters, without LocalText2Voice markup). There is no fallback to English.

The shared service is app/server/voice_design.py, which imports no Qt modules. The original OmniVoice, Breeze and VoxCPM designer dialogs retain their controls and Generate Preview / Play Preview / Save as Voice buttons. They submit POST /voices/design/preview; the host generates and verifies a 48 kHz preview without publishing a catalog voice. After listening, Save as Voice calls POST /voices/design/previews/{job_id}/save. The host checks the verified audio hash and publishes that exact preview, without synthesizing again. Rename and explicit overwrite prompts remain in the UI; the server performs the writes. Preview WAVs are held in the server's design-previews cache. The MCP's POST /voices/design remains the automatic generate/verify/save operation. GET /voices/{voice_id} retrieves saved voices. The existing job queue supplies get_job, get_jobs and cancel_job. A timeout returns the current job; it does not cancel work. Cancellation is cooperative between stages, so an ongoing synthesis or ASR call may finish before cancellation is observed. Once publication commits, the job reports the saved voice even if a cancellation arrives immediately afterward.

The server verifies the mono PCM16 48 kHz master WAV using Whisper on CPU/int8 (beam size 5), without prompting Whisper with the expected transcript. Comparison ignores Unicode case, punctuation and repeated whitespace but retains accents, symbols and word differences. A mismatch fails rather than silently replacing the requested transcript. This is an ASR consistency check, not a measurement of how accurately the voice follows its description.

The verified WAV, exact requested transcript, raw ASR transcript, description, model, effective generation parameters, hash and verification policy are saved together. Names cannot overwrite another voice in the same engine. Retrying the same idempotency_key and request returns the same job; changing its parameters returns a conflict. Use a new key for an intentional new attempt.

Failures have status="failed" and a structured result with code, stage, message and saved=false. Transcript mismatches also include both texts and word differences. Success has job status complete and result.status="saved", with voice_id, name and the saved record. Pass that exact ID as voice to generate_audio or create_audiobook.

Restart the local engine host and reconnect the MCP bridge after updating to load the new routes and tool definitions.

Imported, cloned reference and newly designed voices store two mono PCM16 WAVs, at 24 kHz and 48 kHz, generated independently from the input audio. The catalog keeps one voice name and transcript, with per-rate filenames and SHA-256 hashes. Breeze TTS 2 and VoxCPM 2 automatically use the 48 kHz companion when available; other engines retain the standard 24 kHz reference. Existing references without a companion remain usable. Recreate or reimport from the original recording to retain high-frequency detail: upsampling an old 24 kHz reference cannot restore it. Both files are rolled back on failed import/replacement and removed on voice deletion.

Review's segment details can switch to another installed local engine/model without changing the global selection. Only compatible semantic controls are transferred; engine-specific sampling settings come from the destination. Check the notices, choose a compatible voice/reference and language, then regenerate and approve.

All engines validate WAV output and retry empty audio at most twice using the same engine instance. Existing audio is replaced only after a valid result. Rebuild rejects empty or invalid segment WAVs instead of silently omitting them.

When short-dialogue grouping is enabled, dialogue boundaries suppress automatic pauses, even across voice changes. Explicit {{pause ...}} commands are always preserved, including pauses at the beginning or end of a dialogue.

Created by Esteban at AndromedaNova.com.

If LocalText2Voice helps you, please star the repository. It makes the project easier to discover for people looking for free local AI voice tools.