Beyond the Terminal: Why I Built a Native Swift App for Voice Cloning

If you follow the local AI scene, you've seen the cycle. A new model drops on GitHub — maybe a new Llama variant, maybe a breakthrough in text-to-speech. The excitement is real. Then you scroll down to the "Getting Started" section:

conda create -n voice-env python=3.10
pip install -r requirements.txt   # fails on cmake
export CUDA_HOME=/usr/local/cuda
# download 12GB of weights manually

I love open-source ML. I've spent more hours than I'd like to admit fighting with pip dependency trees. But after years of building things this way, I started to see a gap that nobody seemed interested in closing: the gap between a research artifact and a creative tool.

That gap is what led me to build Speaklone.

The Python Tax

Python is the language of AI research, and for good reason. It's expressive, fast to prototype in, and the ecosystem of ML libraries is unmatched. But for an end user on a Mac who just wants to clone their voice and get back to editing their podcast, Python is a tax — literally and figuratively.

When you run a typical Python-based AI tool, you're standing on a tower of abstractions. There's the Python interpreter itself, the PyTorch runtime (or JAX, or TensorFlow — pick your poison), and usually a web UI layer like Gradio or Streamlit that eats another 500MB of RAM just to render a text input and a slider. On a maxed-out Mac Studio, you might not notice. On a MacBook Air with 8GB of unified memory, that overhead makes the tool unusable.

There's also the maintenance tax. Python environments rot. You come back to a project three months later and half your dependencies have breaking changes. pip install -r requirements.txt fails because someone yanked a package version. You spend 45 minutes debugging your environment before you generate a single audio clip.

Creators shouldn't have to think about any of this. They should double-click an app and start working.

Why Swift + MLX Changes Everything

When I decided to build Speaklone, the non-negotiable requirement was: no terminal, no dependencies, no Python. That meant native code.

I chose Swift and Apple's MLX framework. For those unfamiliar, MLX is a machine learning framework designed specifically for Apple Silicon by researchers at Apple. It's "metal-native" — it talks directly to the GPU and Neural Engine without the abstraction layers that general-purpose frameworks carry.

The key insight is Apple Silicon's unified memory architecture. Traditional GPUs (like NVIDIA's) have their own dedicated VRAM, and data has to be copied back and forth between system RAM and GPU memory. That copy overhead is a bottleneck, especially for large models. On Apple Silicon, the CPU, GPU, and Neural Engine all share the same memory pool. MLX exploits this by using lazy evaluation and zero-copy tensors — the model doesn't move data around, it just points at it.

The practical result: Speaklone runs the Qwen3-TTS 1.7B parameter model (4-bit quantized) on a base M2 MacBook Air with 8GB of RAM. No fan noise. No battery drain. First-packet audio latency under 100 milliseconds on M3 and M4 chips. That's faster than the network round-trip to any cloud TTS API.

What's Under the Hood: Qwen3-TTS

The model powering Speaklone is Qwen3-TTS, an open-source text-to-speech model from Alibaba's Qwen team. It comes in two sizes — a 0.6B parameter lightweight variant and the 1.7B version that Speaklone uses by default. The model was trained on over 5 million hours of multilingual speech data spanning 10 languages, and it's released under the Apache 2.0 license.

That license matters. Apache 2.0 means I can ship the model weights inside a commercial Mac app without royalty concerns or restrictive clauses. It also means the broader community can build on it. Compared to the proprietary models behind services like ElevenLabs, you're not locked into someone else's API — you own the inference pipeline end to end.

The quality surprised me when I first ran it. A 3-second voice sample is enough to produce a clone with natural inflection, emotion, and pacing that holds up in real production contexts. It's not perfect — the top-end cloud models still have an edge on extremely challenging voice types — but it's in the 95th percentile of what most creators actually need.

The Subscription Problem

Beyond the Python tax, there's a third tax in the AI tools world: the subscription tax.

Services like ElevenLabs charge $5 to $99 per month, metered by character count. If you're iterating on a script — trying different reads of the same line, experimenting with pacing — you're watching a meter tick. That changes how you work. You stop playing around. You stop being creative. You start treating generation as a scarce resource.

I built Speaklone with a one-time purchase model: $39.99, or $29.99 during the launch window. No monthly fees. No character limits. No "you've used 80% of your allocation" emails. Generate a million words or ten — same price. If I disappear tomorrow, the app on your Mac keeps working because there's no server dependency to kill it.

I believe the most personal part of your identity — your voice — shouldn't be rented.

Designing for Creators, Not Engineers

The hardest part of building Speaklone wasn't the model porting — it was the UX.

Engineers love parameters. Temperature, Top-P, CFG scale, attention heads. Creators love outcomes. "Make it sound warmer." "Read this like a bedtime story." "More energy."

I spent weeks tuning how the model interprets punctuation and text formatting so that you don't have to be a prompt engineer to get a natural-sounding read. Ellipses create real pauses. Em dashes create slight breaks. Question marks produce genuine rising intonation. The goal was to make the text itself be the interface — type naturally, and the model follows.

Speaklone also includes features that research scripts usually ignore:

9 built-in voices across English, Chinese, Japanese, and Korean — ready to use out of the box.
Unlimited custom clones from as little as 3 seconds of audio.
Batch export — paste a full script, generate the whole thing at once.
Completely offline — airplane mode, no Wi-Fi, no problem.

Where We Are Now

Speaklone is currently in review with Apple. It could go live on the App Store any day now. It's been a wild ride — porting models from Python to Swift, optimizing MLX inference paths, figuring out the App Store review process for an app that ships ML model weights.

I'm nervous, obviously. But every time I hear the app narrate a paragraph in my own voice — locally, instantly, with no server in the loop — I remember why I started this. We don't need a cloud subscription to do amazing things with AI. We just need the right tools running on the hardware we already own.

If you're tired of terminal commands and subscription meters, keep an eye on speaklone.com for launch updates.

— Dylan