Run text-to-speech locally on a Mac: what it takes

How do I run a realistic AI voice model locally on my Mac?

You need three things: an Apple silicon Mac, an open speech model, and something that runs it. The model is a download of a few hundred megabytes to about five gigabytes. The runner is either a Python library such as mlx-audio, or an app that bundles one. After that download, every sentence is generated on your own machine.

That is the short version, and it is true. It leaves out the parts that decide whether you will actually get there: how much memory the model you picked needs, how long a minute of speech takes to render, and whether you want to maintain a Python environment to get it. This guide covers each of those, with numbers, so you can run text-to-speech locally on a Mac without finding out the hard way.

What changed: open models got good

For a long time, a local voice on a Mac meant the system voices. That is no longer the only option. Open models now come with licences that allow commercial use, and some of them clone a voice from a short clip. VoxCPM2, the model we build on, has two billion parameters, speaks 30 languages, outputs 48 kHz audio and was trained on more than two million hours of speech. It is released under Apache-2.0. Kokoro, at the small end, has 82 million parameters and is also Apache-2.0.

Apple silicon is the other half of the change. Its GPU shares memory with the CPU, so a model can sit in ordinary RAM and still run on the graphics cores. Apple's own machine-learning framework, MLX, is built around exactly that shared-memory design, and PyTorch reaches the same GPU through its MPS backend.

The three routes at a glance

There are three ways to get a local AI voice on a Mac, and they trade effort against control:

The rest of this guide walks through each row, then through the hardware, the speed, the quality and the cost. If you only want the answer for your own machine, skip to the hardware requirements.

What a local voice model actually is

A neural voice is a file of learned weights plus the code that turns text into audio with them. Small models like Kokoro have 82 million parameters. Large ones like VoxCPM2 have two billion and can clone a voice from a short reference clip. Size buys expressiveness and cloning. It costs memory and speed.

Nothing about the model is tied to the internet. Once the weights are on your disk, the model reads text and writes audio with no server involved. The cloud versions of these voices are the same idea running on a data-centre GPU, with a meter in front of it. If you want the definition in more depth, our explainer on what on-device text-to-speech is starts there.

Small models and large models

The two ends of the open-model range behave very differently:

• Kokoro (82 million parameters). Kokoro v1.0 ships 54 voices in 8 languages and was trained on a few hundred hours of audio. It is light enough to run almost anywhere, which is why most free local apps use it. It speaks the voices it ships with. Its model card does not describe cloning.
• VoxCPM2 (two billion parameters). It clones a voice from a short clip, designs a new voice from a text description, and outputs 48 kHz audio. It needs real memory: about 8 GB of VRAM on an NVIDIA card according to its model card, and about the same in RAM on a Mac.

Most other open models sit somewhere between these two. Parameter count is not a quality ranking, but it is a fair guide to how much of your Mac a model will occupy. Why a model that size takes several gigabytes, and what is actually in the files, is the subject of what a 5 GB speech model actually stores on your Mac.

Why it needs Apple silicon

The Mac tooling for these models targets Apple's own chips. The kokoro-mlx README says "Apple Silicon required", and mlx-audio lists an Apple silicon Mac as a requirement. PyTorch can run on the Mac GPU through MPS, and its availability check asks for macOS 14.0 or later. An Intel Mac can still run a small model on its CPU in some tools, but none of the fast paths are built for it.

Route one: the voices already on your Mac

macOS ships more than 80 voices in over 60 languages and locales, and Personal Voice can build one that sounds like you, generated on the device. They cost nothing and need no setup. They are built for reading aloud and for accessibility, not for narration you publish.

Spoken Content covers Speak Selection and Speak Screen: highlight text, press a shortcut, and the Mac reads it. Live Speech speaks what you type. Both are good at what they are for, which is listening to a page or speaking on someone's behalf.

Personal Voice is the most interesting of the built-in options. You read 10 randomized phrases, and Apple says the Mac generates a voice that sounds similar to yours in under a minute, on the device. It is limited, though. It needs Apple silicon, it covers English (US), Mandarin Chinese (China mainland) and Spanish (Mexico), and Apple documents it for Live Speech and for third-party apps you allow, such as AAC apps. Apple's guide does not describe exporting it to an audio file.

For a voiceover, a podcast intro or an audiobook chapter, the system voices are the wrong tool. They are a generation behind the open neural models in how they sound. Why that gap exists is the subject of why macOS built-in speech still sounds like a computer.

Route two: run an open model with Python

Install Python 3.10 or later, install mlx-audio or kokoro-mlx with pip, and call the model from a script; the weights download on first use. It costs nothing and you can run nearly any open model. It also leaves you maintaining a Python environment, choosing a model, and writing the code that turns raw output into a finished file.

This is the route most guides describe, and for a developer it is an afternoon. The two libraries that matter on a Mac are:

• kokoro-mlx, an MLX port of Kokoro with no PyTorch dependency. It needs Apple silicon, macOS 13 or later, Python 3.10 to 3.12 and MLX 0.31 or later. Its code is MIT-licensed; the Kokoro weights are Apache-2.0 and come from Hugging Face the first time you run it.
• mlx-audio, a broader MLX library that runs many speech models, VoxCPM2 and Kokoro among them. It needs Python 3.10 or later and an Apple silicon Mac, and ffmpeg if you want MP3 rather than WAV. It also ships a local server that speaks the OpenAI API format, and a web interface you start separately.

A minimal Kokoro setup

1

Get a Python you can install into

Use Python 3.10 to 3.12 in its own virtual environment, so the model's dependencies never touch anything else on the machine.

2

Install the library

Run pip install kokoro-mlx. Japanese and Mandarin need an extra, kokoro-mlx[ja] or kokoro-mlx[zh].

3

Run the quick start

The README's quick start is a few lines of Python: load the pipeline, pass it text and a voice, save the audio. The first run downloads the weights.

4

Turn it into a file you can use

You get audio samples back. Saving them as WAV is a line of code; MP3, chunking a long script, and stitching the pieces back together are yours to write.

Running a large model like VoxCPM2

The same route works for VoxCPM2, with more to manage. Its model card lists Python 3.10 or later and PyTorch 2.5 or later, and its documented speed figures are for NVIDIA GPUs. On a Mac it runs through PyTorch's MPS backend or through mlx-audio. We ran it that way while building txt2mp3, and three things came up that no README mentions:

• Memory doubles on the Mac GPU. VoxCPM2 switches from bfloat16 to float32 on MPS, so the two-billion-parameter model needs about 8 GB of RAM instead of about 4 GB.
• Loading is slow the first time. About 150 seconds cold, most of it downloading, and about 17 seconds once the weights are cached. A script that loads the model per sentence pays that every time; it has to stay resident.
• Timestamps are a separate model. VoxCPM2 does not produce word timings. Captions need a forced-alignment pass with Whisper on top.

None of this is hard for an engineer. All of it is work for a writer or an editor. If that is you, the next route exists for the reader who reads "pip install" and closes the tab, and setting up a local TTS model without the terminal goes through it step by step.

Route three: an app that packages the model

A packaged app downloads the model and its runtime for you and gives you a text box, a voice list and an export button. The free options mostly wrap small models like Kokoro. txt2mp3 wraps VoxCPM2, with voice cloning and MP3 export, for one payment instead of a subscription.

The free apps are worth knowing about. Off Grid AI Desktop is an open-source chat app (AGPL-3.0) that speaks its replies with Kokoro, offline once the model is downloaded; its listing asks for 8 GB of RAM, recommends 16 GB, and needs about 2 GB of disk. OfflineTTS runs Kokoro in the browser on Apple silicon and exports WAV or MP3 at 24 kHz. It says itself that non-English Kokoro sends text to a phonemization service first, so not every language stays on the machine. Both are good ways to hear what a small local model sounds like.

txt2mp3 takes the large-model route and does the engineering from route two for you. On first launch, Setup downloads VoxCPM2, Whisper base for word timings, and a self-contained Python runtime, then never needs the network again for speech. You paste text, pick or clone a voice, generate, and export an MP3 or WAV with an optional timestamp file for captions. A clone takes a reference recording of up to 40 seconds.

Every packaged app is someone else's choices about which model, which voices and which formats. That is the point of it, and also the limit. The commercial guide to the best offline text-to-speech apps for Mac compares them side by side.

Local TTS hardware requirements on a Mac

Any Apple silicon Mac runs a small model like Kokoro. A two-billion-parameter model like VoxCPM2 needs about 8 GB of free memory, because the Mac GPU runs it in 32-bit floats, and about 7 GB of disk once installed. Intel Macs are out for the fast paths: MLX and the tools built on it require Apple silicon.

Memory

Memory is the number that decides which models you can use. On Apple silicon the model lives in the same RAM as everything else you have open, so "8 GB free" means free while your browser, editor and mail are running too. As a rough guide:

• 8 GB Mac: small models are comfortable. A two-billion-parameter model wants about that much memory on its own, so expect heavy swapping and a slow machine while it renders.
• 16 GB Mac: a large model fits with room for a normal working session.
• 24 GB and up: a large model plus a video editor at the same time.

These tiers are our reading of the model sizes above, not a benchmark. What happens to memory, heat and battery during a long render is covered in battery, heat, and memory, and the chip-by-chip detail is in Mac hardware requirements for local neural TTS.

Disk

Disk is the easy one to plan for. Kokoro-based tools ask for around 2 GB. A large-model install is bigger: txt2mp3's Setup downloads 5.11 GB of models (VoxCPM2 at 4.96 GB and Whisper base at 145 MB) and a 411 MB runtime archive that unpacks to 1.58 GB. That is about 6.7 GB in place, and Setup checks for another 2 GiB of free space before it starts, because generated audio and history land on the same disk.

macOS version

The requirement comes from the runner, not the model. kokoro-mlx asks for macOS 13 or later. PyTorch's MPS check asks for macOS 14.0 or later. Personal Voice needs Apple silicon but its guide names no minimum version. If your Mac is on a current macOS, none of this will stop you.

How fast local speech generation runs

On an M3 Max with 36 GB, VoxCPM2 generated speech in about real time: 5.4 seconds of cloned voice took 5.4 seconds, and 4.6 seconds of a designed voice took 7.7. Loading the model took about 17 seconds once its weights were cached. Smaller chips will be slower; small models are much faster.

Those numbers are ours, measured on the feasibility build that became txt2mp3, on one machine:

A real-time factor is render time divided by audio length, so below 1 is faster than real time. At these rates one hour of narration takes roughly one hour to an hour and forty minutes on that Mac. For comparison, VoxCPM2's model card gives a real-time factor of about 0.3 on an NVIDIA RTX 4090, a large desktop graphics card.

An M3 Max is a fast chip, so treat these as an upper bound for a laptop. An M1 or a base M2 will take longer. A small model like Kokoro is a different class: a fraction of the size and correspondingly quicker. We have not measured every chip yet; the full table, as we fill it in, lives in how fast local speech generation is on Apple silicon.

The practical point is that rendering does not have to be fast, because it does not cost anything. A chapter can render in the background while you edit the previous one.

Is local text-to-speech on a Mac as good as the cloud services now?

Close, but not equal. In the Artificial Analysis listening arena, ElevenLabs' v4 models lead with Elo scores of 1330 and 1326. Kokoro, an 82-million-parameter open model that runs on any Apple silicon Mac, scores 1063, level with Google's Chirp 3: HD at 1060 and Amazon Polly Generative at 1066.

That leaderboard is the most useful public evidence there is, because it ranks voices by blind listener preference on one scale. It shows three things:

• The very top is cloud. The highest-ranked entries are hosted models: ElevenLabs' v4, Qwen's TTS-Plus, Sonic and Gemini Flash TTS. Nobody runs those on a laptop.
• Tiny open models already match mid-tier cloud voices. A model small enough to run in a browser tab sits beside the generative tiers Google and Amazon sell by the million characters.
• The gap is in the last stretch. Between Kokoro and the leader sit about 270 Elo points and dozens of models, most of them hosted. Larger open models are where that gap gets closed.

VoxCPM2, the model txt2mp3 runs, is not on that leaderboard, so we cannot give you its score, and we would rather say so than guess. What we can say is that it has about 24 times Kokoro's parameters, clones voices, and outputs 48 kHz audio against Kokoro's 24 kHz.

The honest test is your own script. A score averages across many sentences and listeners; it says nothing about how a model handles your product names or your pacing. Render the same paragraph locally and in the cloud and listen to both. The trial in txt2mp3 speaks 120 characters, which is enough to judge the voice. The broader trade, including speed and privacy, is in local TTS vs cloud TTS.

What running locally costs, and what it saves

The Python route costs nothing but time. A packaged app costs a one-time payment. A cloud plan like ElevenLabs Creator costs $22 every month. At txt2mp3's $29 launch price the purchase is repaid in the second month; at its standing $99 price, in the fifth.

The cloud price is a meter. ElevenLabs Creator includes about 121 minutes of speech a month for $22, and every re-take of a line draws on the same allowance as the first. A local model has no meter: the second take costs a few seconds of your Mac's time, and so does the twentieth. That changes how you work. You stop rationing retakes and start fixing every line that sounds slightly off.

The price is $29 for the launch batch, then $69, then $99 as the standing price as copies sell. Where the per-character meter comes from, and what a finished hour costs on each cloud service, is the subject of text-to-speech cost per character. The head-to-head with the market leader is ElevenLabs alternative without a subscription.

There is a second saving that is easy to miss. Because nothing leaves the machine, an unpublished script, a client's draft or a manuscript under embargo never sits on someone else's server. That is not why most people switch, but it is a side effect of the same design, and keeping scripts off third-party servers covers it.

Where the cloud still wins

The top of the listening charts is still cloud-only. Cloud services cover more languages and ready-made voices, run on Windows and phones, and need no download. If you narrate a few minutes a month, a free tier costs less than any purchase.

• Volume. ElevenLabs' free plan includes about 10 minutes a month. If that covers you, stay there.
• Platform. Everything in this guide needs an Apple silicon Mac. A team on mixed machines, or a server that generates speech on demand, is better served by an API.
• Breadth. A cloud library offers a large catalogue of voices, dubbing, and team features. A local app ships one very good model, presets, and cloning from your own recordings.
• Peak quality. If your work needs the single best-rated voice available today, that voice is hosted.

For one narrator producing many minutes, local wins on cost from the second month. For a cast of forty voices in a dozen languages, it does not. When a local model refuses to start or Setup stalls, troubleshooting a local speech model that will not start covers the common causes.

Frequently asked questions

Where the numbers came from