Miso TTS 8B: a local text-to-dialogue model that asks for a 24 GB GPU

What Miso TTS 8B actually generates

Most text-to-speech models take a string and return a waveform. Miso TTS 8B takes a string plus an optional history of prior turns and returns the next turn. The README calls it a text-to-dialogue model, and the API reflects that: generate() accepts a text argument, a speaker integer, and a context list of Segment objects, each carrying its own text and audio. The model conditions on that history, which is why the same sentence can come out differently depending on what precedes it.

The intended audience is narrow and specific. This is English-only, stated plainly in the model introduction and repeated in the summary table. It is not a lightweight CPU model, and the README says so in bold. Anyone hoping to drop an 8B speech model onto a laptop and get interactive latency should read the system requirements before cloning anything.

The second use case is voice cloning. Prompted generation takes a reference clip, resamples it to the generator's sample rate, wraps it in a Segment with its transcript, and passes it as context. The README describes this as optional and notes that the quickstart runs without prompt audio. There is no separate cloning endpoint or fine-tuning step documented; cloning is just context conditioning.

Two transformers, one frame at a time

The architecture is an RVQ Transformer with two components. A large backbone transformer consumes text and audio-frame embeddings. A smaller decoder transformer then autoregressively predicts the higher-order audio codebooks within each frame. The summary table names the backbone as llama-8B and the audio decoder as llama-300M, with 32 audio codebooks and an audio vocabulary of 2,051.

The audio tokenizer is Mimi, and the README attributes the design to the Sesame CSM architecture. That lineage explains a detail in the dependency list: moshi==0.2.2 is pinned, and the repository ships a moshi_compat.py module at the top level. The max sequence length is 2,048, which bounds how much conversation history the model can attend to at once. Long dialogues will need truncation somewhere in your own code, because the repository does not document a sliding-window scheme for context beyond that limit.

The interleaving of text and audio tokens is what makes prompted generation work without a separate speaker-embedding model. The backbone sees the prompt transcript and the prompt audio in the same sequence, so the speaker identity travels through the same attention path as the text. It is an economical design, but it means prompt quality and prompt transcription accuracy both feed directly into output quality.

Installing Miso TTS with uv and generating a first clip

The README uses uv for the quickstart and offers pip as an alternative. If uv is not on the machine, the install line is a shell script fetched from astral.sh. Then clone, sync with Python 3.10, and activate the virtual environment.

curl -LsSf https://astral.sh/uv/install.sh | sh
git clone https://github.com/MisoLabsAI/MisoTTS.git
cd MisoTTS
uv sync --python 3.10
source .venv/bin/activate

The pyproject.toml constrains Python to >=3.10,<3.13, so 3.10 is the safe choice the README makes. The pip route creates a 3.10 venv, installs the package in editable mode, and runs the script directly.

python3.10 -m venv .venv
source .venv/bin/activate
pip install -e .
python run_misotts.py

Running run_misotts.py loads the public model from MisoLabs/MisoTTS and downloads it into the Hugging Face cache if it is absent. The script writes full_conversation.wav in the repository root. That is the first thing to check: if the file exists and plays, the environment is sound. The README warns that the first run also pulls the SilentCipher watermarking model from sony/silentcipher, and that a timeout there is recoverable by rerunning the command, since the cache resumes from completed files.

For a programmatic first call, the README gives this example. It selects CUDA when available, loads the generator by repository id, and writes a 10-second clip.

import torch
import torchaudio

from generator import load_miso_8b

device = "cuda" if torch.cuda.is_available() else "cpu"

generator = load_miso_8b(
    device=device,
    model_path_or_repo_id="MisoLabs/MisoTTS",
)

audio = generator.generate(
    text="Hello from Miso.",
    speaker=0,
    context=[],
    max_audio_length_ms=10_000,
)

torchaudio.save("miso.wav", audio.unsqueeze(0).cpu(), generator.sample_rate)

The max_audio_length_ms argument is a ceiling, not a target. Setting it to 10_000 caps generation at ten seconds of audio.

The 24 GB floor and the 110 ms number

The system requirements table is the most useful part of the README because it is unusually direct about hardware. In bfloat16 or fp16 the weights are roughly 16 GB and the recommended VRAM is 24 GB, with RTX 3090, 4090, A5000 and L4 listed as examples. In float32 the weights are roughly 33 GB and the recommendation jumps to 40 GB or more. The headroom is not padding: the Mimi codec, the SilentCipher watermarker, the KV cache and activations all live alongside the weights.

The README also preempts a number that circulates in public discussion. The 110 ms latency figure refers to the hosted production API's time-to-first-byte on H100-class hardware, not to the unoptimized local inference path in this repository. Anyone who reads that number and expects it from the code in this repo will be disappointed. The README says to expect materially slower startup and generation latency on consumer or workstation GPUs.

Disk is the second constraint, and it is easy to underestimate. The first run downloads roughly 30 to 40 GB total: the checkpoint plus the Mimi codec, the SilentCipher watermarker and the Llama 3.2 tokenizer, all into the Hugging Face cache. CPU inference is documented as possible but slow, with at least roughly 20 GB RAM for bfloat16 and roughly 40 GB for float32. Consumer GPUs in the 4 to 16 GB range are stated to be insufficient for the full model.

Where Miso TTS 8B is the wrong tool

The English-only constraint is the first hard boundary. If your product speaks Spanish, Japanese or anything else, this model is out of scope, and no amount of prompt engineering changes that. The model card states it as a current limitation rather than a roadmap item.

The second boundary is the licence. The repository reports NOASSERTION, and pyproject.toml points at a LICENSE file rather than declaring an SPDX identifier. That means the terms are whatever that file says, and a reader who needs redistribution or commercial rights has to open it and read it. The terms are not stated anywhere I can quote, so treat an unnamed licence as an unknown, not as permissive by default.

The third boundary is operational. This is inference code, not a serving stack. There is no documented batching, no streaming interface, no server, and no rollback or versioning story. The sequence length caps at 2,048, and the repository does not document how to manage a conversation that exceeds it. If you need a production endpoint with autoscaling, the hosted API at misolabs.ai is the path the README itself points to, and the local code is not a substitute for it.

One more dependency worth flagging: silentcipher is installed from a git URL pinned to a specific commit on the SesameAILabs fork, not from PyPI. That is a supply-chain detail you should be comfortable with, and it means the install depends on GitHub being reachable at build time.

How it compares to a hosted TTS API

The obvious alternative is a hosted speech API, including Miso Labs' own endpoint at misolabs.ai. The difference is not quality, it is where the compute and the data live. A hosted API gives you a network call and someone else's H100s; the 110 ms time-to-first-byte figure the README cites belongs to that path. Miso TTS 8B in this repository gives you the weights, the model definition and the inference script, running on your own card, with your audio never leaving the machine.

That trade is real in both directions. Local inference means you pay for the GPU and the 30 to 40 GB download, and you accept slower generation than the production API. In exchange you get no per-call cost, no rate limit, and no third party holding your prompt audio. For voice cloning specifically, keeping reference clips on your own hardware is often the reason teams choose local inference at all.

Against other open speech models, the distinguishing choice here is the dialogue framing. The context argument and the Segment type make multi-turn conditioning a first-class part of the API rather than something bolted on. If your workload is single-utterance narration, that machinery is overhead you are paying for in VRAM and complexity. If your workload is a back-and-forth conversation, it is the reason to pick this over a plain TTS checkpoint.

Whichever way you go, the watermarking dependency is not optional in the code as shipped: silentcipher is a declared dependency and watermarking.py sits at the top level of the repository.

Maintenance, upgrades and what the pins cost you

The last push to the repository was on 2026-06-09. The repository is not archived. There are no releases retrieved, and the package version in pyproject.toml is 0.1.0, which suggests the project is early in its versioning life rather than settled. Plan for the possibility that the API in generator.py changes without a deprecation window, because nothing in the repository describes a stability policy.

The dependency pins are tight and they are the main upgrade cost. torch and torchaudio are both pinned to 2.4.0, transformers to 4.49.0, tokenizers to 0.21.0, huggingface_hub to 0.28.1, moshi to 0.2.2, torchtune to 0.4.0 and torchao to 0.9.0. bitsandbytes is pinned to 0.45.5 and only on Linux. That combination means you cannot simply take a newer PyTorch for a newer GPU without checking compatibility across the whole set. Upgrading one pin in isolation is likely to break the others.

The Python range is >=3.10,<3.13, so 3.13 is excluded. On the licence side, the repository reports NOASSERTION and pyproject.toml references a LICENSE file by path. Whether that file permits commercial use, redistribution of weights, or derivative models is something you have to read for yourself; I am not in a position to give legal advice, and the repository does not state the terms. The silentcipher dependency points at a specific commit on a third-party fork, so its own licence applies on top of whatever the LICENSE file says.

Editorial conclusion

Adopt Miso TTS 8B if you have a 24 GB GPU, at least 30 to 40 GB of free disk, and a use case that is English conversational speech where you want the inference code in your own environment rather than behind an API. Do not adopt it if you need multilingual output, if your only hardware is a 4 to 16 GB consumer card, or if you want a hosted endpoint without running anything. Before committing, verify three things: that your GPU fits the bfloat16 weights with headroom for the Mimi codec, the SilentCipher watermarker and the KV cache; that the SilentCipher download from the git URL in pyproject.toml completes on your network; and that the licence file in the repository grants the rights your deployment needs, since the repository reports NOASSERTION rather than a named licence.

Frequently asked questions

Official sources

1. Issues
2. MisoLabsAI/MisoTTS on GitHub
3. README