Skip to content
localwork
Go back

I Wanted a Local Transcription App, So I Started Building One

More and more of my professional life happens in meetings, and important things get discussed in them. I wanted to be able to find those things again later.

Discussed in meetings

  1. Decisions
  2. Agreements
  3. Action items
  4. Technical details
  5. Context

I wanted a practical way to capture all of that and go back to it. That meant a transcript, so I went looking for software that could make one.

What was already out there

I started with what already existed, open source and commercial. FluidVoice, OpenWhisper, MacParakeet and Vibe were among the apps I looked at. I wasn’t running a proper comparison, just poking around.

They fell into two camps. Some tried to do everything, with so many features and such complex interfaces that it felt like far too much for what I needed. The lightweight ones were each missing something I wanted.

Then there was the pricing page. I’d find something promising, eventually reach one, and that was often where I lost interest. I don’t mind paying for software. What wore me down was compromising every time: on functionality, on resource usage, on complexity, or on yet another subscription.

What I actually wanted

This is the app I was looking for.

What I wanted

  1. A native macOS app
  2. It can stay open without noticeable idle CPU overhead.
  3. It uses resources while a transcription is actually running.
  4. Lightweight and responsive
  5. Primarily on my own hardware.
  6. No ongoing fee for cloud transcription.
  7. A few useful things, done well
  8. Under my control

None of that is exotic. I just wasn’t finding all of it in one place. Eventually I started wondering whether I could build it myself. That’s how Local Transcriber started.

Drop a file. Get a transcript.

The original README opened with that sentence. Underneath it was a list of things the app wouldn’t do.

README.mdThe original README

Drop a file. Get a transcript.

Among the non-goals

  • No cloud transcription
  • No accounts
  • No URL downloading
  • No summarization
  • No knowledge base
  • No model picker

Several of those lines echo the wish list above, especially local processing and no subscription.

The first evening

I started late in the evening of 27 September 2026. Less than an hour later the first version was in place: a SwiftUI app with a window to drop a file onto, transcription built on Apple’s SpeechTranscriber and SpeechAnalyzer, and an export to Markdown with timestamps.

The transcription part was a single file of about 35 lines. That’s hardly a finished app, and the commit history can’t tell me when it first transcribed anything for real. But I was genuinely surprised by how little code it needed.

I should say who wrote it, because it wasn’t me. Coding agents did, Codex and Claude among them. I’d only bought this MacBook in August 2026 and had never worked with Swift or Xcode. What I did have was experience with systems, workflows, dependencies and user needs, and with reasoning from a problem toward something practical.

I wasn’t writing the code, but I was very much involved in figuring out what to build and why. I questioned the approaches the agents proposed and kept track of what was being built. I also talk things through with an AI sparring partner, a bit like an engineering colleague. I ask it to challenge my hypotheses, pick at my assumptions and explain why something might or might not work, both technically and functionally. While the agents changed the code I followed along in Zed, trying to understand what was being modified, why, and how the pieces fit together. Whenever something didn’t make sense, I asked the sparring partner to explain it.

That’s a big part of why this works for me: I’m learning while building something I actually want to use. Seeing that first implementation come together made something click. I didn’t need to know Swift syntax to start building something useful. I needed to understand what I wanted, ask the right questions, and keep learning enough to judge what the agents were doing.

Still, that evening ended with a prototype, and a prototype only proves so much. The real test was the files I actually wanted to transcribe.

Then real files arrived

The next day I started feeding it real files. I added audio normalization for video, more languages, progress information, and measurements of processing time and speed. On 30 September and 1 October came batch processing and YouTube support, which doesn’t sit well next to the “No URL downloading” line in the original README. On 6 and 7 October I experimented with capturing audio, and on 7 October recording itself arrived, released in version 0.4.0.

Here’s how it grew, and when each part became public.

How it grew

  1. 27 SepFirst working prototype
    The first evening produced an app that could turn one file into a transcript.
    • Drop a file onto the window
    • Transcribe it, in English only
    • Export timestamped Markdown
    Implemented, not yet public
  2. 28 SepMaking it practical
    The next day went into making it work on real files.
    • Audio normalization for video
    • Ten languages
    • Progress indicators
    • Processing time and speed metrics
    Implemented, not yet public
  3. 30 Sep to 1 OctMore ways to transcribe
    One file at a time became a queue, and links joined files.
    • Batch processing
    • YouTube links
    • Automatic output to a chosen folder
    Implemented, not yet public
  4. 5 OctFirst public release
    Everything built so far became a signed, notarized download anyone could install.
    Released · v0.3.0
  5. 7 OctRecording arrives
    A Core Audio capture probe the night before stayed an experiment. Recording itself shipped the same day it was built.
    • Record the microphone
    • Record one app's audio
    • Record both
    Released · v0.4.0
  6. 15 to 17 OctReview and library
    Transcripts became something to open, read and listen to in the app.
    • Timing sidecars
    • Audio review with playback
    • A persistent transcript library
    Released · v0.6.0 and v0.7.0

Details I didn’t expect

Local doesn’t mean offline. The speech recognition runs on my Mac, but Apple’s on-device speech features still need the right language assets, and downloading media or models uses the network.

Languages didn’t all work the same way either. The app uses SpeechTranscriber for the locales it supports and DictationTranscriber for the others. Last time I looked, that meant Dutch, Russian, Turkish and Swedish.

Capturing system audio was more complicated than I expected. I looked into Core Audio taps, and one complication was that browser audio can come from helper processes. ScreenCaptureKit ended up as part of the recording implementation.

The job said it was complete

On 12 October I tested one of my own Dutch recordings, about 12 minutes long, with Local Transcriber, Vibe and MacParakeet. Vibe and MacParakeet both gave me a largely complete transcript. Local Transcriber gave me about 168 words and told me the job was complete. Vibe produced 2,319 words from the same file, and MacParakeet 1,767.

One Dutch recording · about 12 minutes · words in the transcript

Local TranscriberSaid it was doneabout 168 words
Vibe2,319 words
MacParakeet1,767 words

Bars are drawn to scale. These are word counts from one recording, not an accuracy benchmark.

That stung. I’d put real time into this: working out what I wanted, building it with coding agents, following the code and trying to understand how it fit together. And then it was my own app that couldn’t handle the recording.

Running the same file again gave me the same result, even in a separate test harness. So at least I could reproduce it. Figuring out why it happened was another matter. The missing words were already absent from what DictationTranscriber returned. Why it gave me so little, I still don’t know. And I haven’t fixed it.

There’s another gap I already know about. Local Transcriber can’t tell speakers apart, because speaker diarization isn’t implemented. Later I had a meeting where I could’ve really used it. Unfortunately, I hadn’t built that part yet.

Two different projects

The first evening produced something that could make a transcript. Much of what came after has been about whether I can trust one.

One more thing from the wish list. Remember the second item, an app that can stay open without noticeable idle CPU overhead? Something later tested that goal harder than I expected. That’s the next entry.


Share this post:

Previous Post
Why Remote Development Feels Like Cheating
Next Post
The Bug That Made My Mac App Use an Entire CPU Core While Doing Nothing