Apple Silicon Macs have dedicated AI hardware — a GPU that handles machine learning workloads through Metal, and a Neural Engine optimized for model inference. MLX-Audio is one of the first projects to put that hardware to work for audio: text-to-speech and speech-to-text running locally on your Mac, with quality that rivals cloud services.
The project is built on Apple's MLX framework — a NumPy-like array library designed specifically for Apple Silicon. Where PyTorch or TensorFlow route computations through CUDA (which doesn't exist on Mac), MLX talks directly to Metal. The result is efficient GPU utilization for ML workloads without the cross-platform overhead.
MLX-Audio wraps this into a Python library that loads TTS models, runs inference on your GPU, and outputs audio. No cloud API. No per-character pricing. No text sent to anyone's server.
The problem is getting there.
How to install MLX-Audio on Mac
MLX-Audio is a Python library. That means you need a working Python environment before you can touch it. Here's what the actual setup looks like:
Step 1: Python. macOS ships with Python, but it's often outdated or missing pip. Most guides recommend installing Python via Homebrew (brew install python) or pyenv. If you've never managed Python versions on Mac, this is your first detour.
Step 2: Virtual environment. Best practice is to create an isolated environment so MLX-Audio's dependencies don't conflict with your system Python. python -m venv mlx-audio-env && source mlx-audio-env/bin/activate. If you forget this step, you'll debug dependency conflicts later.
Step 3: Install MLX-Audio. pip install mlx-audio. This pulls in mlx, numpy, huggingface-hub, soundfile, and a chain of transitive dependencies. On a fresh environment, expect 20+ packages installed.
Step 4: Download a model. The first time you run inference, MLX-Audio downloads model weights from HuggingFace — typically 500MB to 2GB depending on the model. The download happens silently during your first call, which can look like a hang if you're not expecting it.
Step 5: Write a script. There's no GUI. You write Python code to synthesize speech:
from mlx_audio.tts import generate; generate(text="Hello world", model="prince-canuma/Soprano-80M")
That's five steps, two tools (Python + pip), a virtual environment, a model download, and code — just to hear "Hello world" spoken aloud. For a Python developer, this is Tuesday. For everyone else, it's a wall.
What MLX-Audio does well
Credit where it's due: once you're past the setup, MLX-Audio is impressive.
Genuine quality. Models like Soprano (80M parameters) produce natural-sounding speech with proper pacing, emphasis, and intonation. Orpheus (3B parameters) adds emotional expressiveness — it can sound excited, calm, or somber. These aren't robotic voices from 2015.
Multiple architectures. MLX-Audio supports several TTS model families: Kokoro, Spark TTS, Outetts, CSM, Dia, F5-TTS, Parler, Bark, and more. Each has different strengths — some excel at multilingual output, others at expressiveness or speed.
True local inference. All computation happens on your Mac's GPU via Metal. Your text never leaves your machine. For sensitive content — confidential documents, personal notes, draft communications — this matters.
Apple Silicon optimized. Unlike running TTS through PyTorch on Mac (which falls back to CPU or uses MPS with overhead), MLX talks to Metal natively. GPU utilization is efficient, and inference is fast — Soprano 80M generates speech in near-real-time on an M2.
The friction with MLX-Audio
MLX-Audio is a developer tool. It assumes you have a Python environment, understand package management, and can write scripts. That's a reasonable assumption for its target audience — but it locks out everyone else.
Python dependency management. Virtual environments, pip conflicts, version mismatches between mlx and mlx-audio, numpy version pinning issues. If you've ever seen ImportError: cannot import name 'X' from 'mlx', you know the drill. MLX is under active development, and breaking changes between versions are common.
No user interface. Every interaction is a Python script or a CLI command. Want to try a different voice? Edit the script. Want to change the model? Edit the script. Want to adjust speed or output format? Edit the script. There's no visual interface for experimentation.
Model management is manual. Models download to HuggingFace's cache directory (usually ~/.cache/huggingface/). There's no tool to list what's downloaded, check sizes, or clean up old models. Disk space accumulates silently.
Single capability. MLX-Audio does TTS (and some STT). If you also want an LLM for chat, you install Ollama or llama.cpp separately. If you want OCR, you find another tool. Embeddings for RAG? Another tool. Each capability is a separate Python package with its own dependencies and setup.
No integration. You can't easily chain MLX-Audio's output with other AI capabilities without writing glue code. Want to transcribe audio, summarize it with an LLM, and read the summary aloud? That's three libraries, three setup procedures, and a custom Python script to orchestrate them.
ModelPiper: A visual interface for local TTS
MLX-Audio's biggest gap isn't quality — it's the lack of a user interface. ModelPiper is a free visual AI pipeline builder that gives MLX-Audio models the interface they're missing. Instead of writing Python scripts, you interact with TTS through a web app — pick a voice from a dropdown, type or paste text, hit run, hear it spoken. ModelPiper renders waveforms, plays audio inline, and lets you download results as files.
More importantly, ModelPiper is a pipeline builder. TTS isn't a dead end — it's a block you connect to other blocks. Wire a transcription block into an LLM summarizer into a TTS block, and you've built an audio-in, audio-out workflow without writing a line of code. That integration layer is what no Python script gives you out of the box.
ModelPiper connects to ToolPiper for its local inference — and ToolPiper is where the MLX-Audio models actually run.
ToolPiper: MLX-Audio without the Python
ToolPiper bundles MLX-Audio as a native Swift backend. The same Soprano, Orpheus, and Qwen3 TTS models — running on the same Metal GPU through the same MLX framework — but wrapped in a Mac app that ModelPiper connects to automatically.
Install ToolPiper. Launch it. Open ModelPiper. Load the Text to Speech template. Type text. Click run. Audio plays.
No Python. No pip. No virtual environment. No script. No HuggingFace cache directory to manage. The model downloads with one click from the ModelPiper interface, and you can see exactly how much disk space it uses before downloading.
The same models, without the setup
ToolPiper's MLX Audio backend runs three curated TTS models, all available from the UI:
Soprano 1.1 (80M parameters). Fast multilingual TTS with 8 voices — Tara, Leah, Jess, Leo, Dan, Mia, Zac, Zoe. Uses ~160MB GPU memory. This is the same Soprano model you'd install via pip install mlx-audio, running on the same Metal GPU, producing the same output. The difference is zero setup.
Orpheus (3B parameters). Expressive speech with emotional range. Same 8 voices, but with the ability to convey tone — excitement, calm, emphasis. Uses ~1.88GB GPU memory. Higher quality than Soprano, but needs more RAM.
Qwen3 TTS (0.6B parameters). Multilingual TTS from Alibaba. Supports voice cloning — provide a short audio sample and it synthesizes speech in that voice. Uses ~2.23GB GPU memory. The voice cloning works with a base64-encoded WAV reference audio in the API call.
ToolPiper also includes TTS engines that MLX-Audio doesn't offer:
PocketTTS runs on the Neural Engine (not the GPU), so it generates speech instantly with zero GPU impact. When you need fast narration without competing for GPU resources with an LLM, PocketTTS runs in parallel. MLX-Audio always uses the GPU.
What ToolPiper does that MLX-Audio can't
Replacing MLX-Audio's TTS is one capability. ToolPiper bundles an entire local AI platform into a single app.
Speech-to-text. Parakeet v3 on the Neural Engine — Whisper-class accuracy for transcription. MLX-Audio has experimental STT support, but ToolPiper's is production-ready and runs on dedicated hardware (ANE) so it doesn't compete with TTS for GPU.
LLM chat. llama.cpp on Metal GPU — Llama 3.2, Qwen 3.5, Mistral, DeepSeek, and any GGUF model. With MLX-Audio alone, you need a separate tool for text generation.
Visual pipelines in ModelPiper. ModelPiper's pipeline builder lets you chain TTS with other capabilities by dragging connections between blocks. Transcribe audio → summarize with LLM → read aloud with TTS. Translate text → speak in another language. Ask a vision model about an image → narrate the answer. These multi-step workflows require custom Python scripts with MLX-Audio — in ModelPiper, they're visual connections. The interface is free and runs in your browser.
Voice cloning. Qwen3 TTS supports reference audio — provide a short sample and it speaks in that voice. ToolPiper exposes this through the API and the UI. With raw MLX-Audio, you'd write the audio-loading and model-invocation code yourself.
41 MCP tools. ToolPiper is a full Model Context Protocol server. Claude, Cursor, and any MCP client can invoke TTS, STT, chat, OCR, vision, RAG, browser automation, image/video upscale, and more through a single integration. MLX-Audio has no MCP support.
Resource monitoring. ToolPiper shows per-model GPU memory usage, tracks system RAM pressure, and warns before loading a model that won't fit. MLX-Audio gives you a Python traceback when the GPU runs out of memory.
When MLX-Audio still makes sense
If you're building a Python application that needs programmatic TTS, MLX-Audio is a direct dependency you can pip-install and call from your code. It's a library, and libraries are meant to be embedded in other software.
If you're doing ML research on audio models — fine-tuning, evaluating architectures, benchmarking inference speeds — MLX-Audio gives you direct access to model internals that a GUI app doesn't expose.
And if you're already deep in the MLX ecosystem (mlx, mlx-lm, mlx-audio, mlx-vlm), the consistent API across libraries is valuable. ToolPiper uses mlx-audio-swift under the hood, but it's a different interface.
Try It
Download ModelPiper. Install ToolPiper. Load the Text to Speech template. Pick a voice — Soprano for fast multilingual, Orpheus for expressiveness, PocketTTS for instant Neural Engine output. Type text, hit run, listen.
No Python. No pip. No scripts. Same models, same quality, same Mac hardware.
This is part of a series on local-first AI workflows on macOS. See also: Local Text to Speech — how AI voices work on your Mac, and Voice Cloning — replicate any voice entirely on-device.