Open-source text to speech should be easy to use

Open-source and open-weight text-to-speech models have moved fast. Small projects can now create clear narration, run speech generation locally, and experiment with voices without building a paid API into everything they make. The models are out there. The awkward part is getting from a model page to a voice you can actually hear.

For many people, the first experience with open-source TTS is a GitHub repository, a Hugging Face model card, or a Python notebook. Then come package versions, command-line instructions, model files, runtimes, and hardware choices. None of those things are bad. They are how open projects get built. They are just a rough starting point if your actual goal is to paste in a script and listen to it.

That gap is what Echo Text to Speech is designed to remove. Echo did not create Kokoro, Piper, KittenTTS, or Pocket TTS. Their original teams did the difficult model work. We built a simple interface where more people can use and compare selected models in their browser without first building a Python environment.

Download Echo Live for Windows or macOS to create high-quality speech in any character voice with a compatible RVC model. Type your script, choose Kokoro or Supertonic for speech generation, then apply your character voice through RVC conversion in the same app.

Speech generation and voice conversion run locally. Export the finished clip as a WAV file or save it to the Soundboard. You can use included voices, or import your own compatible character models with Echo Live Pro.

The browser tool remains available for free narration with its own model selection. The desktop app adds the combined text-to-speech and RVC workflow alongside live voice changing.

“Open-source TTS” is useful shorthand, but it can hide several different things. A project may publish its source code, its trained model weights, its voice files, or some combination of the three. Those parts can also use different licenses. Open code does not automatically mean that every voice bundled with it has the same commercial-use terms.

Piper is a good example. The original Rhasspy Piper repository used the MIT license, but it was archived in October 2025 and points developers to a newer GPL-licensed successor. Individual Piper voice models can have separate dataset licenses too. The honest answer to “Can I use Piper commercially?” therefore depends on which engine version and which voice you mean.

The same care matters elsewhere. Kokoro-82M publishes Apache-2.0 model weights. KittenTTS is released under Apache-2.0. Pocket TTS lists CC-BY-4.0 for its model weights. These are real differences, not a boring footnote. If you plan to redistribute a model, ship voices inside a product, or use generated audio commercially, check the exact upstream license for the exact files you use.

Most open TTS projects are created by research and engineering teams. Their first audience is usually other developers, so Python is a sensible common language. The official Kokoro quick start installs a Python package and `espeak-ng`, then loads a pipeline in code. KittenTTS asks for Python 3.8 or later, `pip`, and a package install. Pocket TTS exposes a Python API and command-line interface alongside its browser possibilities.

That setup gives developers control, but it creates friction for everyone else. A creator testing narration should not need to know why a package wants a particular runtime. A student comparing voices should not need to debug a virtual environment. A curious user should not have to decide between ONNX, WebAssembly, WebGPU, CUDA, and CPU before hearing one sentence.

Browser TTS does not make those technical layers disappear. It packages them into a usable product flow. You choose a compatible model, let the browser download the required files, type your text, and generate speech. The interface handles the machinery that would otherwise sit between the repository and the result.

The model creators built the speech technology. Echo built the access layer around it: a consistent place to find models, understand their requirements, install them in browser storage, generate speech, compare results, and save audio. That distinction is central to what we are trying to do.

It is the same idea behind Echo Live, our real-time voice changer. RVC has a huge open ecosystem, but traditional setups can arrive with sprawling Python dependencies and a maze of configuration. Echo Live turns that technology into an app people can install and use. Echo Text to Speech applies the same philosophy in the browser: keep the open ecosystem, remove as much setup friction as possible.

A shared interface also makes differences easier to understand. Model pages can explain download size, language coverage, browser requirements, speed, and licensing in the same format. The TTS compatibility checker can look at the device in front of you instead of assuming every visitor owns a powerful GPU. The browser TTS benchmark lets people measure generation on their own hardware rather than treating someone else’s computer as universal truth.

Echo starts with four projects because they represent different tradeoffs rather than four copies of the same idea.

Kokoro-82M is the balanced starting point. Its official model card describes an 82-million-parameter open-weight model with Apache-2.0 weights. It is small enough to make local use practical while offering a more natural result than many older lightweight systems.

Piper is built around small, fast voices and broad language coverage. It is especially useful when CPU speed and a lighter per-voice download matter more than the most expressive delivery. Because Piper is an engine and voice ecosystem rather than one single file, voice-specific licensing needs extra attention.

KittenTTS Nano is the tiny option. The official KittenTTS project lists its Nano model at 15 million parameters, with a 56 MB standard version and a smaller int8 variant upstream. It is designed for CPU use and makes sense on devices where larger models are a poor fit.

Kyutai Pocket TTS explores streaming and voice cloning in a compact 100-million-parameter model. Kyutai says it runs on CPU and can work client-side in a browser. Its official model card currently describes English-only support, so we are not presenting future language plans as features available today.

There is no universal winner in that group. The right choice depends on what you value: naturalness, speed, language, model size, streaming, cloning, hardware support, or licensing. That is why Echo exposes the choice instead of hiding every use case behind one mystery model.

Open models make a different product model possible. With Echo, speech generation runs on your device after the necessary model assets have downloaded. Echo is not sending every paragraph to a paid speech API and metering each character on our servers. That lets us make the browser interface free to use without a monthly generation allowance.

“Unlimited” still needs an honest definition. There is no Echo character quota or paid generation counter, but your browser and device remain real constraints. A very long script still takes time. A large model still needs storage and memory. Closing a tab can interrupt a job. Older phones and browsers may struggle where a modern desktop works comfortably.

So the practical promise is simple: Echo does not charge by the character or reserve more generations for a paid tier. You can keep generating locally as your device allows. That is more useful—and more honest—than pretending computers have no limits at all.

Yes. A browser interface can run compatible model formats through technologies such as WebAssembly and WebGPU, which means you do not need a local Python setup just to generate speech. The first model load can be substantial because the files still have to reach your device, but later use can draw from the browser’s local cache.

Not every open model belongs in a browser. Some need far more memory, stronger hardware, or runtime features that browser engines do not provide reliably. A useful interface should say that clearly instead of showing an install button that is almost guaranteed to fail.

That is also why “runs locally” does not always mean “works everywhere.” We are building Echo around progressive choices: lightweight CPU models for broad access, larger options for capable desktops, and clear compatibility guidance before a user starts a large download.

The wider open TTS landscape is much bigger than the four models available in Echo today. Projects such as Supertonic 3, Chatterbox, OuteTTS, and MOSS-TTS Nano show different approaches to multilingual speech, voice cloning, model size, and browser deployment.

We expect Echo’s model selection to grow, but a project being interesting does not automatically make it ready for the product. Before adding a model, we need to evaluate whether it actually runs reliably in common browsers, whether its download and memory needs are reasonable, whether users can understand its license, whether the voices have acceptable provenance, and whether it adds something meaningfully different.

The downloadable app is already here: Echo Live includes Kokoro and Supertonic with RVC character conversion. Additional browser engines are evaluated separately; an engine being available in the desktop app does not mean it is available in the browser picker.

Open technology matters because people can inspect it, adapt it, build around it, and choose alternatives. But access is not only about whether files are public. It is also about whether a normal person can get from those files to something useful.

Echo Text to Speech gives selected open models one browser interface. Echo Live brings Kokoro, Supertonic, and RVC character voices together in a desktop app: type a script, generate speech, apply a voice, and save the result.

You can try the current models in Echo Text to Speech for free. Start with a short sentence, compare the options that fit your device, and choose the voice that works for what you are making.