Interview

Inspiration

Every transcription app I tried had the same fine print: your audio gets uploaded to someone's servers, run through a third-party AI company's models, and stored for a while you do not control. For a meeting, a client call, a one-on-one, or an interview, that is a strange trade. The recording is the sensitive part, and the moment it leaves your phone it is no longer yours.

Modern phones now carry enough machine learning to do the whole job locally. I wanted to find out whether an app with no backend at all could produce a transcript good enough to actually rely on: who said what, in what order, in the right language, with a title you can find later. Not a privacy compromise, just a transcription app that happens to never phone home.

What it does

Interview records a sit-down conversation on your phone and turns it into a speaker-attributed transcript you can verify, correct, and share.

• Records with a live waveform, in the foreground or with the screen locked.
• Detects the language of the recording automatically, across eleven supported languages.
• Transcribes with word-level timing.
• Separates speakers and clusters their turns, so a two- or three-person conversation reads like a script.
• Remembers voices. Name a speaker once and the app recognizes them in future recordings. Naming is enrollment.
• Titles each recording using the on-device language model, so the Library is browsable without typing anything.
• Imports audio and video from Files, the share sheet, or other apps, and extracts the audio track from video.
• Exports to DOCX, Markdown, or plain text, named for the person you send it to.
• Keeps working while pocketed. Long imports finish in the background and self-heal missing titles the next time you open the app.

Everything above runs on the phone. The app has no server, no account, and no analytics on your content.

How I built it

The app is Swift 6 with strict concurrency, SwiftUI, and SwiftData, on iOS 26. Almost all of the code lives in a modular Swift package, split so that the processing pipeline talks to audio, speech, and language models only through protocols. The real implementations are injected at the app's composition root.

That separation is what made the project buildable by one person. An hour of audio becoming an attributed transcript runs end to end in a unit test, in milliseconds, on a Mac, with no models loaded and no simulator. Only the thin adapters need a device.

Under those adapters, the app leans on Apple's on-device speech and language frameworks where they are strong, and on open-source on-device audio models where they are not. The part I spent the most time on is the layer in between: how the pieces are combined, how speakers are separated and matched to voices the user has named, and how the model's output is checked against the transcript before it is trusted. That layer is home-grown and was tuned against an evaluation harness rather than by feel.

Long-running imports are handled with the system's background processing APIs, instrumented well enough that I could prove the work finished while the phone sat in a pocket overnight. Export is a small document writer of my own for DOCX, Markdown, and plain text.

Challenges I ran into

• Telling speakers apart was the hardest problem by far. It took seven rounds against an evaluation harness to get from a transcript that needed dozens of corrections to one that needs a handful.
• On-device language models fail quietly. Early titles were confidently wrong, and it took a while to see why. Every model output now has to earn its place before the app shows it.
• Not every language is made of words. Assumptions that held for English broke three of the eleven supported languages, and search and titles broke with them.

Accomplishments that I'm proud of

• A transcript pipeline with zero network calls that you can actually rely on.
• Speaker corrections down from about 78 per recording to about 4.
• The full domain test suite runs on macOS in seconds.
• Eleven languages from day one, with a localization process that catches strings built in Swift as well as literals.

What I learned

• Protocol inversion at the ML boundary is worth every line. It is the difference between a ten-second test loop and a ten-minute one.
• Measure on the device. When an instrument and my eyes disagreed about motion, my eyes were right, and when the simulator and the phone disagreed about anything, the phone was right.
• On-device models fail in specific, fixable ways. Prompt echo, per-character timing, and seam placement were each a day of work once I could see them, and invisible until I built a harness.
• Every feature should propose its own instrumentation, in the form of process events, never content.

What's next

• Speaker identification across more than three voices, and across languages within one recording.
• Searchable, place-aware Library.
• App Store release.

Built With

• accelerate
• apple-intelligence
• avfoundation
• backgroundtasks
• core-ml
• cryptokit
• fluidaudio
• foundation-models
• ios-26
• pdfkit
• speech-(speechanalyzer)
• swift
• swift-package-manager
• swift-testing
• swiftdata
• swiftui
• testflight
• whisperkit
• xcode
• xctest