# How to Vibe Code Your Own MacWhisper (and Stop Paying for It) > Audio and video transcription powered by local AI - Site: https://goodsnooze.gumroad.com - Category: Developer Tools & Utilities - Verdict: **Solid side project** (65/100 vibecodeable) - Estimated effort: 2-3 weekends of focused development and debugging ## Verdict You can build a personal clone of MacWhisper for yourself in a few weekends, but getting the Metal GPU acceleration and native audio hooks rock-solid will test your patience. MacWhisper is fundamentally a thin, highly polished SwiftUI wrapper around open-source Whisper C++ weights running via Apple's Metal framework. While an AI coding agent can scaffold the SwiftUI file list, export formatters, and basic UI instantly, you will hit roadblocks compiling whisper.cpp inside a modern Swift package, managing local model downloads cleanly, and handling edge cases with system audio capture permissions. For personal use, building it is a great weekend project; paying €59 is infinitely more rational if you just want a transcription tool that works today. ### What you can't replicate - Jordi Bruin's brand reputation and integration into the Mac indie community - Years of edge-case bug fixes across hundreds of obscure audio and video codec formats ## What it does MacWhisper converts audio and video files into text locally on your Mac using OpenAI's Whisper models and Nvidia Parakeet via Apple Silicon GPU acceleration. ### Core features - Local audio/video file transcription using whisper.cpp or WhisperKit - Apple Metal GPU acceleration for fast local inference - Support for multiple model sizes (Tiny, Base, Small, Medium, Large, Turbo) - Speaker diarization and timestamp generation - Audio recording hooks from microphone and system audio - Export to SRT, VTT, TXT, CSV, and JSON formats - Batch file processing pipeline - Built-in CLI utility for script automation ## The business ### Pricing - Free: Free — Basic transcription with smaller on-device Whisper models. - Pro: ~€59 — Lifetime purchase for personal use with large models and advanced features. Founded 2022. Team size: 1 (Solo developer). ## The hard parts - Compiling and managing C++ inference runtimes (whisper.cpp) inside a Swift/SwiftUI wrapper - Optimizing memory constraints and GPU weight quantization to run large models on standard consumer MacBooks without thermal throttling - Implementing low-latency system audio capture without breaking macOS audio sandbox permissions - Handling multi-threaded file queueing and batch progress states cleanly in SwiftUI ## How to vibe code MacWhisper ### Prerequisites - Mac with Apple Silicon (Existing hardware): Required for Metal GPU acceleration to run Whisper models locally at usable speeds - Xcode (Free): Required to build and run native macOS Swift applications - Node.js (Free): Required to run helper tooling and AI coding agent runtimes ### Recommended AI tools - Claude Code: Best-in-class agentic CLI tool for scaffolding multi-file Swift projects and debugging native compilation errors - Cursor: Ideal for iterative SwiftUI view design and managing file diffs visually ### Stack - Frontend: SwiftUI (Native macOS) - Backend: Swift (Local process execution) - Database: SwiftData / SQLite (Local file storage) - Auth: None (Local desktop utility) - Payments: None (Personal use clone) - Other: whisper.cpp / WhisperKit (Local ML inference), AVFoundation (Audio playback and capture) ### Hosting - Local Mac (Runs locally as a native macOS application): $0/mo ### Build guide 1. **Scaffold Native macOS App Shell** — Initialize a new SwiftUI macOS application project configured for Apple Silicon with standard window navigation, sidebar file drop zone, and local settings storage. ``` Create a new SwiftUI macOS desktop application structure using Swift package manager or Xcode project layout. Set up a split-view layout featuring a sidebar for navigation (Files, Settings, About), a central drop zone supporting drag-and-drop of audio and video files (mp3, wav, mp4, m4a, mov), and a bottom status bar showing processing progress. Implement a local settings view using AppStorage to save user preferences such as default Whisper model size (tiny, base, small, medium, large-v3, turbo), output format checkboxes (SRT, VTT, TXT, JSON), and language selection. Ensure the app adheres to macOS Human Interface Guidelines with a clean translucent sidebar and Dark/Light mode support. Provide all necessary Swift file structures and Xcode configuration notes. ``` 2. **Integrate WhisperKit / whisper.cpp Engine** — Embed whisper.cpp or WhisperKit into the Swift project to handle offline speech-to-text inference utilizing Apple Metal GPU acceleration. ``` Integrate whisper.cpp or WhisperKit into the Swift project to handle local offline audio transcription. Write a Swift wrapper class (TranscriptionEngine) that manages model file downloads from Hugging Face into the application's Application Support directory, checks for existing weights, and initializes the model with Metal GPU acceleration enabled. Expose asynchronous async/await functions for processing an audio file URL with progress reporting callbacks (0.0 to 1.0). Handle edge cases such as missing model weights, unsupported sample rates, and out-of-memory errors gracefully by catching exceptions and passing descriptive error messages back to the UI state. Provide complete, paste-ready Swift code. ``` 3. **Audio Extraction and Conversion Pipeline** — Implement AVFoundation media extraction to convert imported video and audio files into 16kHz mono WAV files required by Whisper models. ``` Build an audio preparation pipeline using AVFoundation and CoreAudio in Swift. When a user drops a video file (e.g., MP4, MOV) or compressed audio file (e.g., M4A, MP3), the pipeline must extract the audio track, resample it to 16kHz mono PCM WAV format, and store it in a temporary caching directory. Implement cleanup routines to delete temporary files when processing completes or fails. Ensure the UI displays an informative progress indicator during the extraction phase before handing the WAV file over to the TranscriptionEngine. Handle errors gracefully if the media file is corrupted or lacks an audio track. ``` 4. **Transcription Viewer and Export Engine** — Build a rich text viewing interface for transcripts with timestamps and export format generators for SRT, VTT, TXT, and JSON. ``` Create a SwiftUI view for displaying completed transcription results, featuring a split layout with timestamped segments on the left and searchable text on the right. Clicking a segment should copy its timestamp or highlight the text. Implement export utility functions that convert the array of transcribed segments into standard formats: plain text (.txt), SubRip subtitles (.srt), WebVTT (.vtt), and structured JSON. Add an 'Export' button that triggers a native macOS NSSavePanel allowing the user to save the generated files to their desired directory. Include a 'Copy to Clipboard' action with visual confirmation feedback. ``` 5. **Batch Processing Queue and CLI Companion** — Add multi-file batch queueing management and a lightweight command-line interface (CLI) wrapper for terminal automation. ``` Extend the application to support batch processing of multiple audio and video files simultaneously using an actor-based concurrency queue in Swift. Display a queue status list showing individual file progress states (Pending, Extracting, Transcribing, Completed, Failed). Additionally, create a secondary target or command-line executable script in Swift using ArgumentParser that allows running transcriptions headlessly from the terminal by passing an input file path and model size flag. Test that both the GUI queue and CLI tool share the same core transcription engine without locking the UI main thread. ``` ### Cost vs paying **Starting costs (one-time):** - Apple Silicon Mac: Owned hardware - AI Coding Assistant (Claude Pro / Cursor): $20 one-time - Total: ~$20 one-time **Ongoing costs (monthly):** - Local offline execution (Zero cloud API costs): $0/mo - Total: $0/mo - Paying for the SaaS instead: €59 one-time (~$69 USD) - Build time: 15-25 hours - AI tool credits: $20 (Claude Pro / Cursor) - Break-even: N/A (Built for personal utility and learning) ## Sources - [Gumroad Profile - Jordi Bruin (goodsnooze.gumroad.com)](https://goodsnooze.gumroad.com) - [MacWhisper Official Product & Documentation Portal](https://www.macwhisper.com) - [MacWhisper Help Scout Documentation](https://goodsnooze.helpscoutdocs.com)