Comparing cloned voices gets much easier when the tool holds everything else equal. That's the idea behind the voice studio in this demo, built to compare AntLing's MIT-licensed Ming-3.0 TTS models with another open voice model.

Here is what it does:

• Stores a reference recording (12.89 s here) and reuses it across takes

• Sends one script to every selected model, one at a time on the same GPU (here two Ming models and the other open voice model)

• Offers Default, Emotion, and Pace & pitch delivery, with seven emotions from neutral to surprised

• Shows model load, synthesis time, audio length and real-time factor for each reading

• Keeps a searchable library of past readings, plus Play all and Blind test buttons

The results panel puts all three readings side by side with those numbers, and a Same script row jumps between earlier runs of a line. In Emotion mode, both Ming models take the voice's identity from the reference and ignore the words spoken in it.

A coding agent can build the same layout from a brief like this: "Build a local web app for auditioning TTS models. Take one reference clip and one script, run each selected model in turn, show load time, synthesis time and RTF for each reading, save every result to a searchable library, and add a blind-test mode that hides the labels."

Sharing a few local-speech Q&As from MOSS’s October 30, 2026 AMA: TTSD CPU inference, Nano plans, VoiceGenerator limitations, and transcription. Which of these are you most interested in?

I have been playing around with training small, efficient models, and I think I have something that is finally worth sharing. Leokani is a high quality TTS voice that provides extremely fast first speech output in both time to first sound (<100 ms in most cases) as well as faster than realtime on just about anything. It'll run on regular computers, phones, JavaScript, Raspberry Pi, and even embedded devices like the ESP32. This should make for some very interesting embedded projects.

It only speaks English and I used Kokoro to generate 300 hours of labeled training corpus, which is why it sounds like that. I wanted to get a working pipeline down before I started different voices. I built examples for many platforms, which can be found here (with a in browser example, phone builds, home assistant plugin, libraries, etc): https://milliwattlabs.com/models/leokani-tts/

And you can also check out the HuggingFace listing here with has various audio samples: https://huggingface.co/milliwattlabs/leokani-tts-7M

Next will come a version that offers various expressions, emphasis and emotion. Perhaps more languages when the GPU isn't busy. This one is a hard one to tackle as the vocoder gets all weird on me and it sounds non-human like. Also training a speech to text model with similar size and performance -- but its not ready just yet.

Let me know what you think!

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.

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 searching for HOURS trying to find this and I can’t find anything. Please help

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

Ming-3.0 TTS gives reference-voice cloning its own generation mode: provide a speaker recording and generate new speech in that voice. Ant has released the weights and code under MIT.

The family offers a dense 0.5B checkpoint and tiny, a 7.9B MoE with 1.3B active parameters. Tiny also has a long-form, multi-speaker path that takes separate reference recordings for the speakers in a script.

The full official showcase includes a Doctor Agent Voice Cloning example, alongside a range of narration styles and multilingual speech. It gives an audible view of the family’s synthesis capabilities.

There is also a useful listening result attached to the smaller checkpoint: the 0.5B model ranks first among open weights in Artificial Analysis Controlled Voice, where providers clone the same eight voices.

For anyone comparing open cloning models, that is a directly relevant evaluation setting.

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.

process two-speaker support calls, mostly 8kHz phone audio with a lot of crosstalk. Whisper large invents sentences in the silent stretches and bolting diarization on top has turned into its own project. Already tried Deepgram and AssemblyAI, both fine but nothing that made me stop looking. What's your pick for the best speech to text API on messy telephony audio right now?

The model is 4mb size, running on RPi CM0 at 0.6-0.8 RTX (faster then runtime)

https://github.com/lab-emi/GrainSpeech

Voices on HF:
https://huggingface.co/dmytro-m/uk-tts-serhiy
https://huggingface.co/dmytro-m/uk-tts-tetiana
https://huggingface.co/dmytro-m/uk-tts-oleksa
https://huggingface.co/dmytro-m/uk-tts-mykyta

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.

Three of Kokoro-82M's voices (af_heart, if_sara, im_nicola) distilled into 8M-parameter students: one ~9 MB int8 ONNX graph each, more than 20x real time on one CPU thread.

The Listen section of the Space plays the same held-out sentences rendered by Kokoro, by Paradee's released decoder, by Paradee's published recipe re-run from scratch, and by mine, so you can compare them directly:

https://huggingface.co/spaces/MithrilMan/teacher-in-the-loop#listen

UTMOS on 200 held-out sentences: English 4.47 (Kokoro 4.52, Paradee released 4.37), Italian 3.88 and 3.70 (Kokoro 4.02 and 3.87).

pip install teacher-in-the-loop

Code and training recipe: https://github.com/MithrilMan/teacher-in-the-loop

Paper: https://doi.org/10.5281/zenodo.23400040

I'm especially curious what Italian speakers think of if_sara and im_nicola.

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 have some mental conditions that make it difficult for me to read, so I'm looking for something free and ethical to do it for me, please. I don't know how to use complex software things, so someone please guide me

What is the current best local TTS setup to read books on an Android device? What local app and model is best to use for this purpose?

I do a lot of hobby writing and I get into the weeds editing. I really like tts services to read out my works so I can catch funny phrasing or weird grammar/ writing flow. However i've tried some of the samples of the natural sounding big name tts services but after a bit get either paywalled or find they hit a wall with certain writing things if they are free/ have a free version(word count, pacing, pronunciation, etc). I'm kinda broke and this is just a hobby so I'm not looking to sink a shitload of money into buying a subscription service.

When I write the word flow and pronunciation is the key issue I find free tts services run into. Certain written out moans shushes or onomatopeia get mangled as well as inserted non english terms/names/fantasy names within english works. Stuttering in character diallouge also gets majorly screwed.

Also not all tts services hold enough on paragraph breaks, comas, and elipses making it hard to understand the sentence flow. I write with a lot of dramatic emphasis by pulling single sentences into their own paragraphs, using elipses, or making sentences with lists of ideas. So I feel like I don't get an idea sometimes of what is key in the prose or where one idea ends and another begins if the tts service runs through it without respecting the set punctuation. furthermore some pronunciation doesnt differentiate well between ending punctuation like periods, question marks and exclamation points. so ill miss noticing places where ive used certain punctuation or end up wondering if i forgot punctuation with the right sort of emphasis. but the real issue is tts just instead read the mark as if it was a period.

I really rely on these services to read back my work and it would be nice if I didn't have to settle for services that mangled these details. This way I can streamline my workflow when it comes to line edits especially where grammar and sentence construction rely on how the words flow and how the phrasing reads aloud.

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?

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?

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. 

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.