---
title: "Parler TTS vs Kokoro: Local Voice Models for Narration"
description: "Parler TTS steers a voice with a written description; Kokoro uses tiny preset voices. Compare both open-weight models for Mac narration and choose one."
canonical: "https://www.murmurtts.com/blog/parler-tts-vs-kokoro"
---
[Murmur](https://www.murmurtts.com/)/[Blog](https://www.murmurtts.com/blog)/Comparison

Comparison

# Parler TTS vs Kokoro for Narration on a Mac

Parler TTS steers a voice with a written description; Kokoro uses tiny preset voices. Compare both open-weight models for Mac narration and choose one.

![](https://www.murmurtts.com/murmur-icon.webp)Murmur·November 3, 2026·11 min read[Buy $49](https://murmur-licenses.tarunyadav9761.workers.dev/checkout)[Download free for Apple Silicon (3-day Pro trial)](https://murmur-updates.tarunyadav9761.workers.dev/download/latest)Intel Mac? [Download here](https://murmur-updates.tarunyadav9761.workers.dev/download/intel).Not sure? Apple menu > About This Mac shows your chip.

Free plan with Kokoro voices, scripts up to 1,500 characters · 3-day Pro trial, then $49 once

On this page

The difference in one tableWhat Parler-TTS actually isWhat Kokoro actually isParler-TTS versus Kokoro for narration in practiceHow to try each one on a MacWhen Parler-TTS is the better fitWhen Kokoro is the better fitA five-minute decision checklistWhere a studio app such as Murmur fitsFrequently asked questions

[Back to the journal](https://www.murmurtts.com/blog)

**Direct answer:** Parler-TTS and Kokoro are both open-weight text to speech models you run locally, but they are built around opposite ideas. Parler-TTS, an 880 million parameter checkpoint from Hugging Face, shapes a voice through a written description plus one of 34 named speakers, so you direct gender, pitch, speaking rate, and room tone in prose. Kokoro, an 82 million parameter model, gives you a fixed set of preset voices and is valued for being small, fast, and predictable. For plain narration, Kokoro is usually the simpler default. Parler-TTS earns its place when you would rather describe the delivery than pick a preset.

**Disclosure:** we make Murmur, a $49 one-time Mac app that runs speech models locally, so we have a stake in this comparison. Every claim about Parler-TTS and Kokoro below comes from the projects' own repositories and model pages, linked in the sources at the end and checked on October 14, 2026. We did not run a listening test for this article, so no claim here says one model sounds better than the other. Where a number was not published, we say so instead of guessing.

## The difference in one table

| Factor | Parler-TTS | Kokoro |
| --- | --- | --- |
| Parameters | 880M (Mini) and 2.3B (Large) | 82M |
| How you control the voice | A written description plus one of 34 named speakers | A preset voice chosen by name |
| Language coverage | English checkpoints | 8 languages and 54 voices in v1.0 |
| Sample rate | Not stated on the pages checked here | 24 kHz in the official example |
| Reference-clip cloning | Not part of the documented usage | Not supported; preset voices only |
| License | Apache 2.0 | Apache 2.0 |
| Best narration fit | Directing tone, pace, and space in prose | Fast, consistent reads over long passages |
| Mac setup | Python and PyTorch, with a nightly build for bfloat16 | Community MLX builds, or bundled in Murmur |

The table carries the whole decision: description control versus preset control. Everything else follows from that one design choice, and the practical consequence for narration is that Parler-TTS asks you to write, while Kokoro asks you to choose.

## What Parler-TTS actually is

Parler-TTS is an open-source reproduction of research from Dan Lyth at Stability AI and Simon King at Edinburgh University, titled *Natural language guidance of high-fidelity text-to-speech with synthetic annotations*. The project's own framing is unusual: it releases the datasets, the pre-processing, the training code, and the weights together under a permissive license, so the community can fine-tune its own models. The inference library lives at [huggingface/parler-tts](https://github.com/huggingface/parler-tts), and the checkpoints live on Hugging Face.

On August 8, 2024 the project published two checkpoints: Parler-TTS Mini, at 880 million parameters, and Parler-TTS Large, at 2.3 billion parameters. Both were trained on 45,000 hours of audiobook data. The [Mini v1 model card](https://huggingface.co/parler-tts/parler-tts-mini-v1) describes a model that generates speech whose features are set by a text prompt, and it lists the features you can steer: gender, background noise, speaking rate, pitch, and reverberation.

- Describe the speaker: for example, a female speaker with slightly expressive and animated speech, moderate speed and pitch, recorded very clearly and close up.
- Pick a named speaker to keep one identity consistent across generations. The Mini checkpoint was trained on 34 speakers, including Laura, Gary, Jon, Lea, Karen, Rick, Brenda, David, Eileen, and Jordan.
- Use the phrase "very clear audio" to push toward clean output, or "very noisy audio" to add background noise.
- Use punctuation to shape prosody. Commas create small breaks in the speech.

Two practical notes matter for a Mac. First, the checkpoints are English. Second, the project's README states that Apple Silicon users need to run a follow-up command to use a nightly PyTorch 2.4 build for bfloat16 support. In other words, Parler-TTS on a Mac is a Python and terminal workflow, not a double-clickable app, and it expects you to manage a Python environment.

## What Kokoro actually is

Kokoro is the opposite bet. It is an open-weight model with 82 million parameters, roughly a tenth the size of Parler-TTS Mini and more than twenty-five times smaller than Parler-TTS Large. The [Kokoro-82M model page](https://huggingface.co/hexgrad/Kokoro-82M) states that it delivers comparable quality to larger models while being significantly faster and more cost-efficient. Its architecture is StyleTTS 2 with an ISTFTNet decoder, and it is released under Apache 2.0.

Version 1.0 shipped on January 27, 2025, and the release table lists 8 languages and 54 voices. The official example writes audio at 24 kHz and calls the pipeline with a language code and a voice name such as af_heart. Under the hood it uses Misaki for grapheme to phoneme conversion, with espeak-ng as a fallback, and the project notes it was trained exclusively on permissive, non-copyrighted audio.

The language list from the repository covers American English, British English, Spanish, French, Hindi, Italian, Japanese, Brazilian Portuguese, and Mandarin Chinese. The model does not clone a reference voice: you pick a preset. The [hexgrad/kokoro repository](https://github.com/hexgrad/kokoro) also documents a Mac detail, that you can set an environment variable to enable GPU acceleration on Apple Silicon through MPS.

## Parler-TTS versus Kokoro for narration in practice

For a straight read of a blog post or a course lesson, the two models pull in different directions. Kokoro keeps a single preset voice steady across thousands of words, which is exactly what long-form narration wants. Parler-TTS lets you write a delivery instruction once and reuse it, which is powerful when the brief is specific, for example a documentary read that should be slightly faster than neutral with almost no room noise.

- If your narration is English and you want consistent pacing, Kokoro is the lighter path and the easier one to iterate with.
- If your narration needs a particular texture described in words, Parler-TTS can express it without a reference recording.
- If you need languages beyond English, Kokoro's documented set is broader than the English-only Parler-TTS checkpoints.
- If you want the smallest possible footprint for fast drafts, Kokoro's 82M parameters are the reason it feels quick.
- If you want to fine-tune on your own audiobook data, Parler-TTS publishes training code and datasets, and Kokoro does not present the same training-first framing.

Neither model reproduces a specific person's voice from a short clip in its documented usage. If that is your requirement, you want a reference-cloning model instead, and the [cloning, design, and conversion guide](https://www.murmurtts.com/blog/voice-cloning-vs-voice-design-vs-conversion) explains the difference. For a wider view of the field, the [roundup of best local TTS models](https://www.murmurtts.com/blog/best-local-tts-models-2026) puts these two next to the current alternatives.

## How to try each one on a Mac

Both projects document a Python path. These steps follow their own instructions, checked on October 14, 2026, and both assume you are comfortable in a terminal.

1. Parler-TTS: install the library with the project's pip command, pip install git+https://github.com/huggingface/parler-tts.git.
2. Parler-TTS on Apple Silicon: run the follow-up command from the README to use the nightly PyTorch build for bfloat16 support.
3. Parler-TTS: load ParlerTTSForConditionalGeneration from parler-tts/parler-tts-mini-v1, then pass a description string and your text as two tokenized inputs.
4. Parler-TTS: write the output with soundfile using the model's own sampling rate from its config.
5. Kokoro: install with pip install kokoro soundfile, then install espeak-ng for English out-of-vocabulary fallback and some non-English languages.
6. Kokoro: build a KPipeline with a language code, call it with a voice name such as af_heart, and write each chunk to a wav file at 24 kHz.
7. Kokoro on Apple Silicon: set the MPS fallback environment variable the README describes if you want GPU acceleration.
8. Either model: keep the exact description or voice name in your notes so a regenerated line still matches the rest of the project.

One thing to expect with Parler-TTS is iteration. Because the voice lives in a sentence you wrote, small word changes shift the result, so you will likely generate a few versions before the delivery lands. Kokoro's preset approach trades that flexibility for repeatability, which is friendlier when you are generating chapter after chapter.

## When Parler-TTS is the better fit

- You want to direct the delivery in words, including pace, pitch, and how close or noisy the recording sounds.
- You are working in English and want to try several deliveries of the same script quickly.
- You care that the model, its training code, and its datasets are all published, and you may fine-tune later.
- You are building a developer workflow and are comfortable managing Python and PyTorch on a Mac.
- You want the option of the larger 2.3B checkpoint when a project needs more capacity.

## When Kokoro is the better fit

- You are narrating long passages and want one steady voice throughout.
- You want the smallest, fastest model to run repeated drafts without waiting.
- You need one of the other documented languages, such as Spanish, French, Japanese, or Mandarin Chinese.
- You prefer to pick a voice by name and skip writing delivery instructions.
- You want the option of a polished app instead of a command-line script.

## A five-minute decision checklist

1. Name the deliverable. If it is a spoken read of existing text, start by assuming Kokoro. If it is a directed performance of a specific script, look at Parler-TTS.
2. Name the language. English only? Both qualify. Anything wider? Kokoro's documented set is the shorter decision.
3. Decide whether you want to write or to pick. Description control is Parler-TTS. Preset control is Kokoro.
4. Check your comfort with setup. Both are terminal projects, so budget time for Python before you judge either model.
5. Check licensing. Both are Apache 2.0, but review the current model card yourself before commercial work.
6. Listen to the official samples. Kokoro publishes sample pages, and both models offer a space or demo where you can hear them before you install anything.
7. Only then compare effort. The model you can set up and finish a project with is worth more than the one with the better spec sheet.

For narration voices specifically, the [guide to TTS voices for narration](https://www.murmurtts.com/blog/best-tts-voices-for-narration-2026) covers how to judge pacing and clarity, and the [Kokoro TTS guide for Mac](https://www.murmurtts.com/blog/kokoro-tts-mac-guide) walks the setup in more detail. If you want to understand the MLX runtime that makes macOS inference practical, [the Kokoro and ONNX background piece](https://www.murmurtts.com/blog/nvidia-kokoro-tts-onnx-local-ai-voice) and [the MLX TTS explainer](https://www.murmurtts.com/blog/what-is-mlx-tts) are useful companions.

## Where a studio app such as Murmur fits

Murmur is a local-first macOS app for Apple Silicon and Intel Macs running macOS 15 or later. It costs $49 one time, has a free plan and a 3-day Pro trial, and carries a 7-day refund policy. It does not bundle Parler-TTS, so if you specifically want description-controlled voices from Parler, the app is not the tool for that. What it does provide is the bundled Kokoro model, whose preset voices cover English, Spanish, Japanese, Chinese, French, Hindi, Italian, and Portuguese according to its in-app list, plus optional models that add reference voice cloning and a Voice Design mode that builds a voice from a written description.

The reason to reach for an app rather than a script is the project around the model: naming voices, keeping a session organized, regenerating one line, and exporting a finished file. That is time saved, not quality added, and it is worth saying plainly that if your work lives in code and you enjoy it there, staying with Parler-TTS or Kokoro on the command line is a perfectly good answer. If you need Windows, Linux, a browser, or live streaming, none of these Mac options is the right fit at all.

The honest summary: Kokoro is the easier default for preset-voice narration, Parler-TTS is the more expressive tool when you want to steer a voice with language, and both are Apache-licensed, terminal-first projects. A Mac studio app is a convenience layer over that same model family, not a replacement for the models themselves. Check the model list in the app before you plan a project around any specific engine, and read the current model cards before commercial use.

## Frequently asked questions

## Sources

- [huggingface/parler-tts official repository (release notes, named speakers, prompt controls, Apple Silicon note)](https://github.com/huggingface/parler-tts)Accessed 2026-10-14
- [Parler-TTS Mini v1 model card (880M parameters, 45K hours, controllable features, license)](https://huggingface.co/parler-tts/parler-tts-mini-v1)Accessed 2026-10-14
- [hexgrad/Kokoro-82M model card (82M parameters, v1.0 release, 8 languages and 54 voices, 24 kHz)](https://huggingface.co/hexgrad/Kokoro-82M)Accessed 2026-10-14
- [hexgrad/kokoro official repository (languages, Misaki, espeak-ng, Apple Silicon MPS note)](https://github.com/hexgrad/kokoro)Accessed 2026-10-14

## Try preset-voice narration in Murmur

Murmur is a local voice studio for Apple Silicon and Intel Macs running macOS 15 or later. Kokoro is bundled for preset-voice narration, and optional models add reference voice cloning and Voice Design. It is $49 one time, with a free plan and a 3-day Pro trial, and a 7-day refund policy. Listen to the public samples before you buy, and keep Parler-TTS or Kokoro on the command line if your work lives in code.

[Buy Murmur · $49](https://murmur-licenses.tarunyadav9761.workers.dev/checkout)[Download free for Apple Silicon (3-day Pro trial)](https://murmur-updates.tarunyadav9761.workers.dev/download/latest)Intel Mac? [Download here](https://murmur-updates.tarunyadav9761.workers.dev/download/intel).Not sure? Apple menu > About This Mac shows your chip.

macOS 15+ · Apple Silicon and Intel Macs · Windows beta · 7-day refund policy

Made for your Mac

## Less reading. More making.

[Buy $49](https://murmur-licenses.tarunyadav9761.workers.dev/checkout)[Download free for Apple Silicon (3-day Pro trial)](https://murmur-updates.tarunyadav9761.workers.dev/download/latest)Intel Mac? [Download here](https://murmur-updates.tarunyadav9761.workers.dev/download/intel).Not sure? Apple menu > About This Mac shows your chip.[Explore Murmur](https://www.murmurtts.com/#product)