---
title: "Alias TTS: the audio was never the hard part"
date: 2026-07-29T07:00:00-04:00
author: John Morton
canonical_url: "https://supergeekery.com/blog/alias-tts-the-audio-was-never-the-hard-part"
section: Blog
---
# Alias TTS: the audio was never the hard part

*July 29, 2026* by John Morton

![Alias tts the audio was never the hard part](https://static.supergeekery.com/site-assets/alias-tts-the-audio-was-never-the-hard-part.png)

*Audio narration available for this post.*

*The story of a long-standing love of audio, an open model that gave me the same jolt ElevenLabs did the first time I heard it, and the unglamorous quality-control layer that turned it into something I’d actually put my name on.*

## First, what is Alias TTS?

[**Alias TTS**](https://alias.morton.dev/) is a self-hosted text-to-speech service for creating natural-sounding audio in a cloned voice. It wraps open voice models in the less glamorous machinery a real application needs: long-form generation, sentence-aware chunking, audio cleanup, storage, and automatic checks for flawed takes. It also speaks the same API languages as ElevenLabs and OpenAI, so an existing application can use it by changing little more than its base URL and API key.

That’s what it is technically. The reason I built it starts somewhere more personal.

## **It starts with a love of audio**

I’ve been an audio person for a long time, and it pulls at me from two directions.

One is the craft. I love making audio — the editing, the pacing, the small choices that decide how a line lands. But let me be clear about something up front, because it shapes everything else: I don’t think listening is *better* than reading. Reading is a fantastic experience in its own right, and I’d never want to trade it away. To me the two aren’t rivals so much as companions — parallel routes to the same words, and you take whichever one suits the moment you’re in.

The other pull is personal. I get migraines. I’m also someone who loves to read. Those two don’t get along: when a migraine settles in, a screen full of text is the last thing I want, but I still want the words. So I listen instead — an article, a blog post, a whole book. Put it in my ears and the migraine stops standing between me and the thing I wanted to read.

Once you’ve needed audio that way, a “listen to this post” button stops looking like a novelty. The readers it matters most to are the ones many people would name first: those who are blind or have low vision, for whom a spoken version isn’t a convenience but the way in. And it reaches further still — tired eyes, a migraine, a long commute, a screen someone can’t look at right now. Alongside the writing, audio lets a wider audience get to the words.

Put those two pulls together — the love of making the audio and the need to have it — and you get the reason I built the [**Bespoken**](https://plugins.craftcms.com/bespoken?craft5) plugin for Craft CMS: a way to give any article a spoken version, so a reader who’d rather listen — or who can’t comfortably read right now — can press play and let the piece read itself to them. I released it publicly in September 2024, after a good stretch of building it in private first, and it’s been quietly doing that job ever since.

Under the hood, Bespoken called out to ElevenLabs, and landing there took some shopping around. I’d auditioned a stack of text-to-speech services, and at the time it genuinely wasn’t close — ElevenLabs was the best by a wide margin. That alone would’ve sold me. But the real light-bulb moment came when I tried the voice cloning: I fed it a sample of my own voice and had it read a paragraph of my writing back to me — in my voice, saying words I’d written but never spoken aloud. I played it three times in a row. Not to check it. Just because it was a strange and wonderful thing to hear.

That’s the feeling the whole project is chasing.

## **Then I met Chatterbox**

A while later I came across **Chatterbox**, the open text-to-speech model from Resemble AI. I ran a clip through it on Replicate, cloned my own voice from about twenty seconds of me talking, and had it read a paragraph back.

There it was again — my own voice, my own words, the same jolt I’d had with ElevenLabs. Except this time the model was open, I could run it myself, and there was no monthly ceiling standing behind it. I sat there and listened to the clip a few more times than I’ll admit to.

*When it landed a good take,* Chatterbox stood right next to the commercial services. That qualifier is going to do a lot of work later in this post.

## **The meter in the corner of my eye**

Here’s a bit of friction I only noticed by watching my own behavior over time.

ElevenLabs bills against a monthly balance of credits. It’s a completely reasonable way to price a service, and I want to be clear that none of what follows is a complaint about ElevenLabs — their product is excellent and I still admire it.

I should also own the other half of it: I’m probably extra price-sensitive here. SuperGeekery is a personal blog. I don’t write it to make money, so every dollar the audio cost came straight out of my own pocket for something that was never going to earn it back. Against that, a premium rate gets hard to justify.

But a meter changes how you work. I noticed I’d started rationing. I’d hesitate to regenerate a take I wasn’t quite happy with, because that regeneration cost something. Toward the end of a busy month I’d catch myself sitting on a finished piece rather than spend the last of the credits — or bump up to the next plan for a single heavy week and then not need it again. The friction was small, but it was always there, quietly nudging me toward “good enough” and “publish it later.”

For a workflow that’s inherently iterative — generate, listen, tweak, generate again — a finite meter is exactly the wrong shape.

Chatterbox on Replicate is usage-based, no subscription, and the numbers aren’t close. A roughly 1,200-word article runs about **$1.31** at ElevenLabs’ Creator-plan rate. The same text through Chatterbox costs me somewhere around **$0.18**, and I only pay for what I actually generate. Suddenly regenerating a take cost about a penny, and “should I really spend credits on this?” stopped being a question I had to ask.

## **The drop-in replacement that wasn’t (yet)**

My first plan was the obvious one: point Bespoken at Chatterbox instead of the commercial API and call it done. A drop-in swap. Same plugin, cheaper backend, keep moving.

It *almost* worked. And “almost” turned out to be the entire project.

Chatterbox is non-deterministic. Most takes were great. But every so often it would drop the last word of a sentence, or trail off into a strange low hum after the speech ended, or simply stop reading a line partway through. In a single short clip you just re-roll it and move on. Across a 1,200-word article stitched together from dozens of chunks, one bad chunk meant regenerating the whole thing — and the friction I’d just escaped came right back, wearing a different hat.

That’s when the actual insight showed up, and it reframed everything:

**The model was never the hard part. Guaranteeing the output was.**

Access to a strong generative model is basically a commodity now. What didn’t exist — what I actually needed — was the layer that turns inconsistent output into something dependable enough to publish. If I could build *that*, I wouldn’t have a cheaper ElevenLabs. I’d have the thing I’d been reaching for the whole time.

So in June 2026 — nearly two years after Bespoken first went public — I started building it. Raw Chatterbox, straight off the open model, wasn’t reliable enough to put in front of readers, and it wasn’t something I’d suggest to the handful of people running my plugin either. If I wanted that voice, I’d have to build the reliability around it myself. That project became **Alias TTS**.

## **Building the thing, one failure mode at a time**

What follows is roughly the order it actually happened. The repo itself is private, but I’ve worked to keep its changelog an honest record of the evolution — it’s now well past seventy releases, and looking back, almost every version is me discovering one more way audio can go subtly wrong.

### **First, stop paying for the whole article**

The earliest work was unglamorous plumbing: split long text into short, sentence-aware chunks, generate each one, and stitch them back into a single file. Chatterbox is a short-form model, so it needed this anyway — but the real prize was that once each sentence is its own chunk, fixing one bad line means re-rolling one chunk, not re-rendering the whole article.

That one idea — *the file is not the unit of work* — quietly became the spine of the whole product.

### **The seams hissed**

Then I actually listened to the stitched files, and nearly every seam had a problem.

Chatterbox, it turns out, appends a faint noise tail to a lot of its generations — a little “swoosh” of hiss after the speech stops. On any one clip you’d barely notice. But stitch forty clips together and enough of them are swooshing that the hiss lands right at the sentence and paragraph breaks, where the ear is most primed to hear it.

The first fix was easy: trim each clip’s tail before stitching it in. Then I found longer tails — multi-second low-frequency drones. Built a detector for those. Then a short, loud “re-swell” blip that sat past the drone and slipped through the first detector. Then a tonal swell that ramped *up* over a full second. Each one got its own acoustic test — zero-crossing rate, loudness relative to the speech, how long the tail ran.

And each fix created its own hazard: cut too eagerly and you clip a real word. A quiet word ending in a soft “n” or a trailing “s” looks a lot like noise to a naive trimmer, and I spent more evenings than I’d like teaching the thing the difference between “…built *in*” and a hum. (The trick, in the end, was loudness: a real word tapers *off*, an artifact is *louder* than the speech around it.)

Somewhere in the middle of all this I built the piece that changed the shape of the product: **Studio**. Paste in text, see exactly how it’ll be chunked, generate the chunks, and — the important part — edit a single sentence and re-synthesize only that chunk. That’s the moment Alias stopped being a script I ran and became a tool I used.

### **The model just… stopped**

Here’s the failure mode with no tell at all: there’s nothing to detect.

Sometimes Chatterbox just ends a line early. It reads “The quick brown fox jumped over the” and stops. No hiss, no drone, no artifact — the audio is *clean*, it’s just missing words. Every acoustic trick I’d built was useless against it, because acoustically nothing is wrong.

The only way to catch a truncation is to *listen and read along.* So I gave the system ears: a local Whisper speech-recognition sidecar that transcribes every generated take and compares the transcript back to the script it was supposed to read. If words are missing, if the take truncated, if there’s a long stall in the middle or noise where there shouldn’t be — it flags the chunk, re-rolls it automatically, and keeps the best valid result.

That was the turning point where Alias started checking its own work instead of trusting it.

### **Keep every take**

The next idea came straight out of my background in video and audio production.

In a real studio, you don’t record one take and ship it. You record several, and you assemble the best moments. So Alias started keeping **every** take — every generate, every re-roll, every automatic quality re-roll — as its own immutable clip you can audition, compare, and select. Nothing gets overwritten. A better earlier take is never lost to a worse later one.

Once every take is a durable, addressable asset, “regenerate everything” collapses into “re-roll the one line that’s wrong.” That’s the whole game.

### **Making “final” actually final**

The last piece is the one I care about most, and it comes straight out of my years in production.

If you’ve ever produced anything, you know these files. `episode-final.mp3`. Then `episode-final-v2.mp3`. Then `episode-final-FINAL.mp3` — and, inevitably, `episode-final-FINAL-for-real.mp3`. I’ve made so many “final” versions of so many things that I lost count a long time ago. Final is only final until it isn’t.

So Alias lets me seal one. A finished project can be **sealed**: Alias records the SHA–256 of the exact approved bytes, snapshots them, and lets me download a self-contained receipt — the final audio, a human-readable production record of what each chunk actually said, a machine-readable manifest, and every saved take, including the rejected re-rolls. From then on, “final” isn’t a hopeful filename — it’s a fingerprint. Anyone can later drop the file onto a verify page and confirm it’s the untouched approved cut, with the fingerprint checked right in their browser and the audio never leaving their device. The moment I edit anything, the seal clears itself, so an “approved” stamp can never outlive the audio it described.

Underneath all of it sits [**Genblaze**](https://github.com/backblaze-labs/genblaze), Backblaze’s open-source Python SDK for building AI media pipelines with provenance baked in. It drives the generate → score → re-roll → stitch loop behind one provider-agnostic interface — I wrote the adapters that plug Alias’s own engines into it — and writes a verifiable provenance manifest for every run. **Backblaze B2** then durably stores every take and every manifest in a private bucket. The rejected takes matter as much as the chosen ones: they’re the evidence that a human sat there and listened before signing off.

## **Where it landed**

Along the way, the drop-in replacement I’d given up on quietly came true. Alias speaks both the ElevenLabs *and* OpenAI TTS dialects, so an existing integration switches over by changing a base URL — and my Bespoken plugin now runs on Alias in production. It became the drop-in replacement after all, just with an entire studio standing behind it.

The rest filled in around that: voice cloning you can record and clean up right in the browser, a second faster engine with expressive tags like `[laugh]` and `[sigh]`, a fully local mode for offline development, prepaid credit accounting, and something north of 700 automated tests keeping me honest.

The name took a while to land, and I sweated it more than you might expect — I started out in advertising, where naming a thing is part of working out what it actually is. It went through a few names as I built it (for a while it was “Mimic,” until that turned out to collide with an existing TTS engine, and it never really captured the idea anyway). **Alias** was the one that finally clicked, because it means two things at once: a drop-in alternate endpoint standing in for a commercial one, and an assumed identity that is, underneath, still you. Which is exactly what a cloned voice is.

## **The part that surprised me**

I built Alias assuming its audience was developers. The API compatibility felt like the killer feature — point your existing integration at it, get a cheaper and far more editable pipeline, done.

The reaction I didn’t expect came from friends — the non-technical ones. I’d shown Alias to a few of them the way you show anyone what you’ve been pouring your evenings into, not because I thought they’d have any use for it. But the Studio clicked for them right away: generate, compare, keep the best, assemble the final is just how anyone who’s edited audio or video already thinks, API or no API. What caught me off guard wasn’t that they were polite about it — it’s that a couple of them wanted to try it themselves. One, a documentary filmmaker, has said he’d like to play around with it.

That reframed a question I’m still chewing on: I aimed Alias at developers, but the people who actually reached for it might be the ones who’d never touch an API.

## **Where this leaves me**

I’ve spent seventy-odd releases on Alias, and I mostly use it for the thing I wanted at the very start: to hear my own posts in my own voice on the days reading is a chore — and, lately, to actually trust what I hear.

I can’t tell you what Alias really is yet, or who it’s ultimately for. And I won​’t pretend I’ve settled it. It’s a question I keep circling back to — whether Alias stays just mine, or turns into something I hand to other people. The building itself I’m not worried about; I’ll keep tweaking and improving it, because that part comes easily to me. It’s the next step that’s hard: opening the gate and actually inviting people into a playground I built for myself. That’s always been the hardest part for me, and it’s exactly where I’m standing now.

---

**Tags:** audio

## Related Posts

- [Bespoken 5.3.0: Long-Form Audio, Credit Tracking, and Multisite Support](https://supergeekery.com/blog/bespoken-530-long-form-audio-credit-tracking-and-multisite-support)