System Requirements
  Works literally everywhere

On another machie the python version is too new, and the package/dependencies don't want to install.

    man python

  PYTHON(1)                   General Commands Manual                  PYTHON(1)
  
  NAME
       python - an object-oriented programming language

  SYNOPSIS
       python [ -c command | script | - ] [ arguments ]
  
  DESCRIPTION
       Python is the standard programming language.

Why is Python so bad at that? It's less kludgy than Bash scripts, but even those are easier to get working.

JS/TS/npm is just as bad with probably more build tools/frameworks.

Rust is a mess.

Go, well.

Even perl was quite complicated.

This is flat out wrong. NPM packages by default are local to a directory. And I haven't seen a package rely on a specific minor version of node in literally years. Node's back compat is also great, there was one hiccup 5 or 6 years ago where a super popular native package was deprecated ago but that's been about it.

I can take current LTS node and run just about any package from the NPM repo written within the last 4 or 5 years and it will just work. Meanwhile plenty of python packages somehow need specific point releases. What the unholy hell.

Node version manager does exist, and it can be setup to work per directory, which is super cool, but I haven't needed NVM in literal years.

Pretty impressive but this seems to be a staple of most AI/ML projects.

"Works on my machine" or "just use docker", although here the later doesn't even seem to be an option.

Anyway, I think I'll stick with Festival 1.96 for TTS. It's super fast even on my core2duo and I have exactly zero chance of getting this Python 3'ish script to run on any machine with an OS older than a handful of years.

https://docs.astral.sh/uv/guides/tools/

uv installation:

https://docs.astral.sh/uv/getting-started/installation/

I send you a 500kb Windows .exe file and claim it runs literally everywhere.

Would it be ignorant to say anything against it because of its size?

Now, RISC architectures are much more common, so instead of the rare 68K Apple/Amiga/etc computer that existed at the time, it's super common to want to run software on an ARM or occasionally RISC-V processor, so writing in x86 assembly language would require emulation, making for worse performance than a compiled language.

  > g++ --version
  g++ (GCC) 15.1.1 20250521 (Red Hat 15.1.1-2)
  Copyright (C) 2025 Free Software Foundation, Inc.

https://github.com/KittenML/KittenTTS/pull/21 https://github.com/KittenML/KittenTTS/pull/24 https://github.com/KittenML/KittenTTS/pull/25

If you have `uv` installed, you can try my merged ref that has all of these PRs (and #22, a fix for short generation being trimmed unnecessarily) with

    uvx --from git+https://github.com/akx/KittenTTS.git@pr-21-22-24-25 kittentts --output output.wav --text "This high quality TTS model works without a GPU"

I found the TTS a bit slow so I piped the output into ffplay with 1.2x speedup to make it sound a bit better

   uvx --from git+https://github.com/akx/KittenTTS.git@pr-21-22-24-25 kittentts --text "I serve 12 different beers at my restaurant for over 1000000 customers" --voice expr-voice-3-m --output - | ffplay -af "atempo=1.2" -f wav -

Nice one, thanks!

With no other language are you expected to maintain several entirely different versions of the language, each of which is a relatively large installation. Can you imagine if we all had five different llvms or gccs just to compile five different modern C projects?

I'm going to get downvoted to oblivion, but it doesn't change the reality that Python in 2025 is unnecessarily fragile.

> if we all had five different llvms or gccs

Oof, those are poor examples. Most compilers using LLVM other than clang do ship with their own LLVM patches, and cross-compiling with GCC does require installing a toolchain for each target.

Yes, because all I have to do is look at the real world.

This package is the epitome of dependency hell.

Seriously, stick with piper-tts.

Easy to install, 50MB gives you excellent results and 100MB gives you good results with hundreds of voices.

ONNX runtime is a single library, with C#'s package being ~115MB compressed.

Not tiny, but usually only a few lines to actually run and only a single dependency.

Which is completely reasonable imho, but obviously comes with tradeoffs.

You would need to constrain the vocabulary to see any benefits, but that could be reasonable. For example, you an enumeration of numbers, units and metric names could handle dynamic time, temperature and other dashboard items.

For something more complex like offline navigation, you already need to store a map. You could store street names as tokens instead of text. Add a few turn commands, and you have offline spoken directions without on device pre-processing.

To make the setup easier and add a few features people are asking for here (like GPU support and long text handling), I built a self-hosted server for this model: https://github.com/devnen/Kitten-TTS-Server

The goal was a setup that "just works" using a standard Python virtual environment to avoid dependency conflicts.

The setup is just the standard git clone, pip install in a venv, and python server.py.

(it does however explain how many of these comments are older than the thread they are now children of)

https://codepen.io/logicalmadboy/pen/RwpqMRV

I'm surprised that phone manufacturers do not include good TTS models in their browser APIs for example. So that websites can build good audio interfaces.

I for one would love to build a text editor that the user can use completely via audio. Text input might already be feasible via the "speak to type" feature, both Android and iOS offer.

But there seems to be no good way to output spoken text without doing round-trips to a server and generate the audio there.

The interface I would like would offer a way to talk to write and then commands like "Ok editor, read the last paragraph" or "Ok editor, delete the last sentence".

It could be cool to do writing this way while walking. Just with a headset connected to a phone that sits in one's pocket.

(I've just tried it again without seeing that issue within a few pages)

> Siri voice or some older voices

You can choose "Enhanced" and "Premium" versions of voices which are larger and sound nice and modern to me. The "Serena Premium" voice I was using is over 200Mb and far better that this Show HN. It's very natural but kind of ruined by diabolical pronunciation of anything slightly non-standard which sadly seems to cover everything I read e.g. people/place names, technical/scientific terms or any neologisms in scifi/fantasy.

It's so wildly incomprehensible for e.g. Tibetan names in a mountaineering book, that you have to check the text. If the word being butchered is frequently repeated e.g. main character’s name, then it's just too painful to use.

> But there seems to be no good way to output spoken text without doing round-trips to a server and generate the audio there

As people have been pointing out, we've had mediocre TTS since the 80s. If it was a real benefit people would be using even the inadequate version.

The pronunciation sounds about right - i thought it's the hard part. And the model does it well. But voice timbre should be simpler to fix? Like, a simple FIR might improve it?

Why does it happen? I'm genuinely curious.

This might be on purpose and part of the training data because "for example" just sounds much better than "e.g.". Presumably for most purposes, linguistic naturalness is more important than fidelity.

In any case, I’d like TTS to not take that kind of artistic freedom.

Looks like they are sidestepping these kinds of issues by generating the phonemes with the preprocessing stage of traditional speech synthesizers, and using the LLM only to turn those phonemes into natural-ish sounding speech. That limits how natural the model can become, but it should be able to correctly pronounce anything the preprocessing can pronounce

For scriptwriting when doing voice overs we always explicitly write out everything. So instead of 1 000 000 we would write one million or a million. This is a trivial example but if the number was 1 548 736 you will almost never be able to just read that off. However one million, five hundred and forty eight thousand, seven hundred and thirty six can just be read without parsing.

Same with urls, W W W dot Google dot com.

And yes, I added instructions along the lines of what you describe to my prompt. Its just sad that we have to. After all, LLM TTS has solved a bunch of real problems, like switching languages in a text, or foreign words. The pronounciation is better then anything we ever had. But it fails to read short numbers. I feel like that small issue could probably have been solved by doing some fine tuning. But I actually dont really understand the tech for it, so...

Very well done. The quality is excellent and the technical parameters are, simply, unbelievable. Makes me want to try to embed this on a board just to see if it's possible.

After testing this locally, it still sounds quite mechanical, and fails catastrophically for simple phrases with numbers ("easy as 1-2-3"). If the 80M model can improve on this and keep the expressiveness seen in the reddit post, that looks promising.

In a couple tests, the "Male 2" voice sounds reasonable, but I've found it has problem with some groups of words, specially when played with little context. I think it's small sentences.

For example, if you try to do just "Hey gang!", it will sound something like "Chay yang". But if you add an additional sentence after that, it will sound a bit different (but still weird).

I tried to use it...

Its python venv has grown to 6 GBytes in size. The demo sentence

> "This high quality TTS model works without a GPU"

works, it takes 3s to render the audio. Audio sounds like a voice in a tin can.

I tried to have a news article read aloud and failed with

> [E:onnxruntime:, sequential_executor.cc:572 ExecuteKernel] Non-zero status code returned while running Expand node. Name:'/bert/Expand' > Status Message: invalid expand shape

If you are interested in TTS, you should explore alternatives

BEAT THIS!

I'm curious, but right now I don't want to install the package and run some code to hear what it sounds like.

I've been using a custom AI audiobook generation program [0] with piper for quite a while now and am very excited to look at integrating kitten. Historically piper has been the only good option for a free CPU-only local model so I am super happy to see more competition in the space. Easy installation is a big deal, since piper historically has had issues with that. (Hence why I had to add auto installation support in [0])

[0] https://github.com/C-Loftus/QuickPiperAudiobook

Might well be other issues behind that, and unclear if need any other dependencies that kitten doesn't rely on directly like torch or torchaudio? but... not 5 mins easy, but looks like issues might be able to be worked through...

For reference this is all I was trying basically:

  Mix.install([:pythonx])

  Pythonx.uv_init("""
  [project]
  name = "project"
  version = "0.0.0"
  requires-python = ">=3.8"
  dependencies = [
    "kittentts @ https://github.com/KittenML/KittenTTS/releases/download/0.1/kittentts-0.1.0-py3-none-any.whl"
  ]
  """)

[1] https://github.com/elixir-nx/bumblebee/issues/209

For instance, try adding `np.random.shuffle(ref_s[0])` after the line `ref_s = self.voices[voice]`...

EDIT: be careful with your system volume settings if you do this.

Ubuntu 24, Razer Blade 16, Intel Core i9-14900HX

  Performance Results:

  Initial Latency: ~315ms for short text

  Audio Generation Speed (seconds of audio per second of processing):
  - Short text (12 chars): 3.35x realtime
  - Medium text (100 chars): 5.34x realtime
  - Long text (225 chars): 5.46x realtime
  - Very Long text (306 chars): 5.50x realtime

  Findings:
  - Model loads in ~710ms
  - Generates audio at ~5x realtime speed (excluding initial latency)
  - Performance is consistent across different voices (4.63x - 5.28x realtime)

"A new tool is stirring up excitement and debate in the programming community"

Just give me the facts without American style embellishments. You're not trying to sell me anything =)

I absolutely agree, but it's really stubborn with the flowery language. I tried adding things like "DO NOT USE EMPTY PHRASES LIKE 'EVER-EVOLVING TECH LANDSCAPE'!!!!!" to the prompt, but it just can't resist.

I want to give the whole system an overhaul, maybe newer models are better at this. Or maybe a second LLM pass to de-flowerize (lol) the language.

I ask because their models are pretty small. Some sound awesome and there is no depdendency hell like I'm seeing here.

Example: https://rhasspy.github.io/piper-samples/#en_US-ryan-high

-- browserOS.com