---
title: "Kokoro TTS on Mac: Local Setup, Voices & Samples"
description: "Hear Kokoro on Mac, follow MLX-Audio setup, choose compatible voices, and fix common installation and audio-output problems on Apple Silicon."
canonical: "https://www.murmurtts.com/blog/kokoro-tts-mac-guide"
---
[Murmur](https://www.murmurtts.com/)/[Blog](https://www.murmurtts.com/blog)/Guide

Guide

# Kokoro TTS on Mac: Setup, Voices, and Audio Samples

Hear Kokoro running in Murmur, set up the MLX-Audio command line, and fix common voice, installation, and output problems on Apple Silicon.

![](https://www.murmurtts.com/murmur-icon.webp)Murmur·May 22, 2026·9 min read

On this page

Hear Kokoro on a MacChoose Your Kokoro Mac PathIn This GuideWhat Kokoro TTS IsWhat You Need on a MacHow to Install Kokoro With MLX-AudioCommon Kokoro setup problemsThe Official Kokoro Python Route Is DifferentKokoro Voices and Languages on MacKokoro vs Qwen3-TTS on MacPronunciation and Chunking for Long ScriptsUsing Kokoro Through MurmurKokoro Commercial-Use and Privacy CaveatsFrequently Asked Questions

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

Kokoro is one of the easiest local TTS models to recommend on an Apple Silicon Mac. It has 82 million parameters, runs through Mac-focused MLX tooling, offers more than 50 preset voices, and uses an Apache 2.0 license that permits commercial use under the license terms. Choose a manual MLX or Python setup if you want code-level control. Choose a native app such as Murmur if the real job is importing scripts, previewing voices, queueing sections, and exporting audio every week. Kokoro is not a voice-cloning model and it is not the best answer for every language or dramatic performance. If you need cloning, natural-language voice design, or broader expression controls, Qwen3-TTS or Chatterbox may fit better.

## Hear Kokoro on a Mac

This English recording was generated in Murmur with Kokoro and the Heart preset. Use it to hear the voice before setting up the model. It is a listening example; generation time and peak memory were not recorded.

Kokoro · Heart · English narration0:00

**Full script:** Some ideas start as a scribble. A sentence in your notes. A story you cannot stop thinking about. Give yours a voice.

## Choose Your Kokoro Mac Path

| Path | Best for | What you manage | Main tradeoff |
| --- | --- | --- | --- |
| MLX-Audio CLI or Python | Developers and automation | Python, packages, model ID, commands, files | Most control, more setup |
| Official Kokoro Python library | Testing the upstream pipeline | Python, Misaki, eSpeak, PyTorch device path | Official examples, separate from MLX |
| Murmur native Mac workflow | Creators and repeated production | Scripts, voices, projects, export | $49 one-time, no free trial |
| Built-in macOS speech | Basic read-aloud | System voice and playback settings | Not the same model or production workflow |

## In This Guide

1. What Kokoro is and what it does not do
2. Apple Silicon requirements
3. How to install Kokoro with MLX-Audio
4. How the official Python route differs
5. Kokoro voices and language codes
6. Kokoro versus Qwen3-TTS
7. Pronunciation and long-script workflow
8. Commercial-use licensing and FAQs

## What Kokoro TTS Is

Kokoro is an open-weight text-to-speech model with 82 million parameters. That is unusually compact beside the 0.6B and 1.7B Qwen3-TTS checkpoints or the multi-billion-parameter Fish Audio S2 Pro model. Small does not automatically mean better or worse. It means Kokoro is easier to place in a fast local narration workflow, especially when a creator needs repeated revisions rather than one polished demo.

The [official Kokoro repository](https://github.com/hexgrad/kokoro) documents American English, British English, Spanish, French, Hindi, Italian, Japanese, Brazilian Portuguese, and Mandarin Chinese pipelines. The official example writes 24 kHz WAV audio. Kokoro uses the Misaki grapheme-to-phoneme library, with eSpeak for English out-of-distribution fallback and some non-English processing.

Kokoro supplies preset voices. It does not natively clone a person's voice from a recording, and it does not create a completely new speaker from a natural-language description. Those jobs belong to other model families. Kokoro's strength is the simpler loop: pick a compatible language and voice, set a speed, generate, listen, revise, and export.

## What You Need on a Mac

- An Apple Silicon Mac for the documented MLX-Audio path.
- Python 3.10 or newer for current MLX-Audio installation.
- Enough storage for the selected Kokoro checkpoint and generated audio.
- ffmpeg only if you need MP3, FLAC, OGG, Opus, or Vorbis encoding. WAV works without ffmpeg.
- A representative script that includes the names, numbers, acronyms, and punctuation you actually publish.

Apple's [MLX framework](https://github.com/ml-explore/mlx) is designed for Apple Silicon. It uses unified memory shared across CPU and GPU operations, so MLX arrays do not need explicit transfers between those devices. That architecture makes MLX a practical base for Mac-native machine learning, but it does not guarantee the same generation speed on every M-series chip or memory configuration.

## How to Install Kokoro With MLX-Audio

The [MLX-Audio documentation](https://github.com/Blaizzy/mlx-audio#requirements) lists Python 3.10 or newer and Apple Silicon. The commands below follow that documentation, checked on 9 September 2026. The recording above comes from Murmur’s native Kokoro runtime; it does not verify this Python installation.

Create a separate environment so the speech packages do not change the dependencies of another project:

`python3 -m venv .venv`
`source .venv/bin/activate`
`python -m pip install --upgrade pip`
`python -m pip install mlx-audio`

Generate a short English clip with Heart and save the output in a known directory:

`mlx_audio.tts.generate --model mlx-community/Kokoro-82M-bf16 --text "Hello from Kokoro running locally on my Mac." --voice af_heart --output_path ./kokoro-output --join_audio --play`

The first run downloads the checkpoint, so it needs an internet connection and can take longer. After generation, check `./kokoro-output` for the WAV file and play it through to the end. `--join_audio` combines generated segments; without it, the CLI can write separate numbered files. WAV output does not require ffmpeg. Save the installed version with `python -m pip show mlx-audio` before putting this command into automation.

## Common Kokoro setup problems

| Symptom | What to check | Next step |
| --- | --- | --- |
| mlx_audio.tts.generate: command not found | The active Python environment | Activate .venv and run python -m pip show mlx-audio. Install into that environment if the package is absent. |
| Model download fails | Network connection, free disk space, and the model repository name | Retry the same short script after fixing the reported download error. |
| Several short WAV files appear | The CLI split the text into segments | Use --join_audio when you need one combined file. |
| Names or words sound wrong | The voice language and spelling of the input | Match the voice to the language, expand ambiguous abbreviations, and test a single sentence. |
| eSpeak or PyTorch/MPS error | Whether you followed the upstream Kokoro Python route | Follow the dependencies for that route. PYTORCH_ENABLE_MPS_FALLBACK does not configure MLX. |

### The MLX-Audio Python API

The Python API loads `mlx-community/Kokoro-82M-bf16` with MLX-Audio's `load_model` utility, then calls the model's generation function with text, a voice such as `af_heart`, speed, and a matching language code. Use this route when Kokoro needs to sit inside a larger script, local API, batch process, or custom app.

## The Official Kokoro Python Route Is Different

The upstream Kokoro package is a separate PyTorch path. The official examples install Kokoro and SoundFile, then create a `KPipeline`. They also install eSpeak NG. On an Apple M1, M2, M3, or M4 Mac, the repository suggests setting `PYTORCH_ENABLE_MPS_FALLBACK=1` when running the script.

1. Install the Python packages with pip install "kokoro>=0.9.4" soundfile.
2. Install the phonemizer dependency on macOS with brew install espeak-ng.
3. Create a KPipeline using the language code that matches the voice.
4. Generate a short sample before processing a long script.
5. Use PYTORCH_ENABLE_MPS_FALLBACK=1 for the official PyTorch Mac acceleration path when needed.

Do not combine instructions casually. The PyTorch environment variable does not configure MLX, and MLX-Audio's model loader is not the same API as the official Kokoro `KPipeline`. Pick one stack, follow its current documentation, and record the package version in any production automation.

## Kokoro Voices and Languages on Mac

The current MLX-Audio documentation lists 54 Kokoro preset voices. Voice IDs encode a language or accent group and a speaker category. For example, `af_heart` is an American English female preset, `bm_george` is a British English male preset, `jf_alpha` is Japanese, and `zf_xiaobei` is Mandarin Chinese. The exact voice must match the selected language code.

| Language or accent | Code | Example voice | Extra note |
| --- | --- | --- | --- |
| American English | a | af_heart | Default in many examples |
| British English | b | bm_george | Use a British-compatible voice |
| Spanish | e | ef_dora | Test names and regional vocabulary |
| French | f | ff_siwis | French pipeline |
| Hindi | h | hf_alpha | Hindi pipeline |
| Italian | i | if_sara | Italian pipeline |
| Japanese | j | jf_alpha | Misaki Japanese extras may be needed |
| Brazilian Portuguese | p | pf_dora | Portuguese pipeline |
| Mandarin Chinese | z | zf_xiaobei | Misaki Mandarin extras may be needed |

More voices do not mean every voice is equally strong for every script. Generate the same 100 to 200 words with three plausible presets. Include proper nouns, dates, prices, abbreviations, and a sentence with the emotional tone you need. Choose the voice that survives the difficult parts, not the voice that sounds nicest saying one easy line. Browse Murmur's [local voice workflows](https://www.murmurtts.com/voices) when you want to compare model families in the app.

## Kokoro vs Qwen3-TTS on Mac

| Decision | Kokoro | Qwen3-TTS |
| --- | --- | --- |
| Checkpoint size | 82M parameters | 0.6B Base or 1.7B VoiceDesign |
| Voice source | Preset voices | Reference cloning or description-based design |
| Documented languages | 9 language or accent pipelines | 10 languages |
| Voice cloning | No | Yes with Base |
| Voice design | No | Yes with 1.7B VoiceDesign |
| License | Apache 2.0 | Apache 2.0 |
| Best project type | Fast narration and repeated drafts | Cloning, multilingual work, designed voices |

Kokoro wins on simplicity and footprint. Qwen3-TTS wins when the voice itself is part of the creative requirement. The 0.6B Qwen3-TTS Base model accepts reference audio for rapid cloning, while the 1.7B VoiceDesign model creates a speaker from a written description. Qwen's 10 languages are Chinese, English, Japanese, Korean, German, French, Russian, Portuguese, Spanish, and Italian.

Do not turn the comparison into an unsupported speed promise. Qwen reports streaming latency as low as 97 ms in its technical materials, but that is not a benchmark for every Mac. Kokoro's smaller parameter count suggests a lighter workflow, yet actual time depends on model precision, text length, chunking, runtime version, and chip. See the [Qwen3-TTS guide for Mac creators](https://www.murmurtts.com/blog/qwen3-tts-for-multilingual-narration) and the broader [best local TTS models comparison](https://www.murmurtts.com/blog/best-local-tts-models-2026) before choosing.

## Pronunciation and Chunking for Long Scripts

A clean long-form workflow starts before generation. TTS reads what you write, not what you intended. Expand ambiguous abbreviations, write dates in the form you want spoken, and replace visual formatting that has no spoken equivalent. Add punctuation where a narrator should breathe. If a product name is consistently wrong, use a phonetic spelling in the generation copy while preserving the original in the published text.

1. Normalize headings, bullets, URLs, symbols, and abbreviations into spoken text.
2. Test one paragraph containing every difficult name and number.
3. Split long work at semantic boundaries such as paragraphs or scenes, not arbitrary character counts.
4. Keep the selected language code and voice compatible for every segment.
5. Listen across joins for a sudden change in pace, energy, or silence.
6. Export a lossless WAV master before compressing for distribution.
7. Save the final generation text beside the audio so revisions remain reproducible.

Chunking improves recoverability as well as pronunciation. If a five-minute section needs one correction, you can regenerate that section instead of an entire chapter. The downside is continuity. Keep voice, speed, language, and text-normalization rules fixed, then review the transitions in headphones before publishing. The [audiobook narration workflow](https://www.murmurtts.com/use-cases/audiobook-narration) covers the larger production process.

## Using Kokoro Through Murmur

Murmur's current model catalog marks Kokoro as bundled and routes it through a native Swift service built on MLX-Audio. The app exposes American and British English, Spanish, Japanese, Mandarin Chinese, French, Hindi, Italian, and Portuguese voices, plus speed control. The current code defines more than 50 Kokoro presets. Because the model is bundled, creators can start with Kokoro without selecting a multi-gigabyte optional checkpoint.

The productized route is useful when the task is not machine-learning experimentation. Murmur handles voice selection, text input, projects, queueing, preview, and export in a Mac interface. It also lets a creator move from Kokoro to Qwen3-TTS, Chatterbox, or another supported model without building each user interface from scratch. Learn how the local runtime works in plain English in [What Is MLX TTS?](https://www.murmurtts.com/blog/what-is-mlx-tts).

Murmur costs $49 one-time. There is no free trial, and the purchase has a 7-day refund policy. Larger optional models still need to download before local use, and every model keeps its own license terms. An app can simplify the workflow, but it cannot convert a non-commercial model license into a commercial one.

## Kokoro Commercial-Use and Privacy Caveats

Kokoro's official repository and weights use Apache 2.0. That permissive license allows commercial use, modification, and distribution subject to its terms, including preserving required license and notice material when distributing covered software or derivatives. This is a model-license answer, not legal advice about an entire project.

You still need rights to the script, music, sound effects, trademarks, and any other assets in the finished work. Kokoro uses preset voices rather than cloning an uploaded person, which removes one consent decision but not every rights question. Local generation also improves script privacy only when the surrounding workflow remains local. Cloud storage, online transcription, collaboration tools, and backup services can still transmit the source text or audio.

## Frequently Asked Questions

## Use Kokoro without maintaining a Python project

Murmur bundles Kokoro into a local Mac workflow with voices, previews, projects, queueing, and export. It costs $49 one-time, with no free trial and a 7-day refund policy.

[Buy Murmur · $49](https://murmur-licenses.tarunyadav9761.workers.dev/checkout)

macOS 15+ · Apple Silicon required · 7-day refund policy

MADE FOR YOUR MAC

## Less reading. *More making.*

[Explore Murmur](https://www.murmurtts.com/#product)