Yap, Whisper, and Cloud STT: Choosing a Voice Dictation Stack for macOS Apps (2026)

Yap, an open-source on-device voice dictation app for macOS that requires no model download, hit the Show HN front page with 276 GitHub stars in days. It joins a crowded field: Apple's SpeechAnalyzer API, Whisper and whisper.cpp, and a dozen cloud STT providers. This article maps the trade-offs with benchmarks, pricing and a decision framework.

What Is Yap and Why It Matters

Yap is a free, open-source macOS menu bar app built by Frigade that does fully on-device voice transcription. Press a shortcut (default ⌘⇧D), talk, press again, and the text lands in whatever field you were typing in. No account, no API key, no audio leaving the device.

The technical differentiator is what Yap does not ship: a model. It relies entirely on Apple's SpeechAnalyzer and SpeechTranscriber APIs, introduced in macOS 26 (Tahoe). The OS manages the speech model, so the app itself is roughly 3,000 lines of native Swift in a 4 MB binary, idling at ~60 MB of RAM, no browser engine, no multi-gigabyte model bundle, no network calls.

Yap runs on Apple Silicon only (macOS 26+). Intel Macs are unsupported because the older SFSpeechRecognizer API can fall back to Apple's servers when no on-device model exists for a locale, and that breaks Yap's core promise of zero network egress.

The Three Deployment Tiers

Every voice dictation implementation falls into one of three tiers. The right choice depends on your latency budget, accuracy requirements, privacy constraints, and volume.

Tier 1: Fully On-Device (Yap, whisper.cpp, Apple SpeechAnalyzer)

On-device transcription runs entirely on the user's hardware. No network round-trip, no per-use cost, no data leaves the device.

Apple SpeechAnalyzer (via Yap or direct API):

• Latency: streaming, sub-200ms for partial results

• Cost: zero per-use; the model ships with the OS

• Privacy: strongest possible, audio never leaves the device

• Accuracy: 2.12% WER on clean speech, 4.56% on noisy audio (benchmark across 5,559 LibriSpeech clips), better than Whisper Small (3.74% / 7.95%) at ~3× the speed

• Limitation: requires macOS 26 on Apple Silicon; locale coverage depends on Apple's shipped models

whisper.cpp (self-bundled):

• Latency: 200ms–2s depending on model size and hardware

• Cost: zero per-use; you bundle the model

• Model size: whisper-large adds ~1.5 GB to your app; whisper-small ~250 MB; whisper-tiny ~75 MB

• Accuracy: whisper-large approaches cloud accuracy; whisper-small is the practical floor for dictation

• Limitation: heavy model bundle inflates app install size; inference is slow on older or Intel Macs

The Yap approach, leveraging the OS-provided model, sidesteps the model-bundle problem entirely. The trade-off is platform lock-in: your app only works on macOS 26+ Apple Silicon.

Tier 2: Self-Hosted Server (whisper-large on your GPUs)

You run Whisper (or a fine-tuned variant) on your own infrastructure and expose it as an API.

• Latency: 100–500ms depending on network and GPU utilization

• Cost: amortized GPU cost; works out to fractions of a cent per minute at scale

• Control: full model choice, fine-tuning capability, no vendor lock-in

• Privacy: audio travels to your servers, but you control retention and processing

• Complexity: you own the infrastructure, scaling, and model updates

This is the right tier for organizations with existing GPU capacity, strict data-control requirements, and the engineering bandwidth to maintain a serving stack (vLLM, TGI, or a custom Whisper server).

Tier 3: Cloud STT API (Deepgram, AssemblyAI, Google, EdenAI Multi-Provider)

Cloud APIs offer the best accuracy on noisy and multi-speaker audio, with zero infrastructure overhead.

Pricing verified April 2026. Batch rates are cheaper; streaming adds a premium. Additive costs (diarization, PII redaction, custom vocabulary) are sold as extras by most providers, ElevenLabs Scribe includes diarization at its flat rate.

A multi-provider API (like EdenAI's unified STT endpoint) lets you A/B test providers per audio clip and route by language, noise profile, or cost, switching from Deepgram to AssemblyAI to Google Chirp without code changes.

Decision Framework: Which Tier Should You Ship?

Technical Implementation: Apple SpeechAnalyzer in Swift

If you are building a native macOS app and want the Yap-style approach (no model bundle, OS-provided transcription), here is the core pattern:

import Speech

// 1. Request authorization
let authStatus = await SFSpeechRecognizer.requestAuthorization(
    .speechRecognition
)
guard authStatus == .authorized else { return }

// 2. Create a SpeechTranscriber with volatile results for live preview
let config = SpeechTranscriber.Configuration()
config.volatileResults = true  // enables streaming partial transcripts

let transcriber = SpeechTranscriber(configuration: config)

// 3. Ensure the on-device locale model is available
let locale = Locale(identifier: "en-US")
try await AssetInventory.shared.downloadIfMissing(
    .speechRecognizer(locale)
)

// 4. Start transcription from an audio input stream
let analyzer = SpeechAnalyzer()
let stream = transcriber.stream(
    from: audioInput,
    using: analyzer
)

for try await result in stream {
    // result.transcript: the running transcript (volatile = live preview)
    print(result.transcript)
}

Key implementation notes from Yap's architecture:

• Audio capture starts before the speech stack initializes. Buffers recorded in that window are held and flushed once the transcriber attaches, so the first word is never clipped.

• Do not use SFSpeechRecognizer. The older API can fall back to Apple's servers when a locale has no on-device model. SpeechAnalyzer runs on-device only, if your language is unsupported, dictation stops rather than sending audio to Apple.

• Insertion via clipboard + ⌘V. Yap writes text to the clipboard, triggers paste through System Events, then restores the previous clipboard. It waits before restoring because Chromium-based apps read the pasteboard asynchronously, restoring too early hands the renderer stale data.

Cloud STT with Python (Multi-Provider via EdenAI)

For apps that need cloud-grade accuracy with provider flexibility:

import requests

API_KEY = "your_edenai_api_key"

response = requests.post(
    "https://api.edenai.run/v3/audio/speech_to_text",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "providers": "deepgram,assemblyai,google",
        "file": open("audio.mp3", "rb"),
        "language": "en",
        "provider_settings": {
            "deepgram": {"model": "nova-3"},
            "assemblyai": {"speaker_labels": True}
        }
    }
)

data = response.json()
for provider in ["deepgram", "assemblyai", "google"]:
    print(f"{provider}: {data[provider]['text']}")

This pattern lets you call multiple providers in a single request, compare outputs, and route based on which provider performs best for your audio distribution, without maintaining separate SDK integrations.

Pitfalls and Practical Advice

• On-device model size matters for app install. Bundling whisper-large adds ~1.5 GB. Yap's no-download claim is the hard part, it works because Apple ships the model with the OS. If you target pre-macOS 26 or non-Apple Silicon, you must bundle your own model.

• Cloud STT terms of service vary on training. Some providers train on your audio by default. Verify for regulated workloads, check the data processing agreement before integrating.

• Accuracy benchmarks lie. Provider demo sets are cherry-picked. Always test on your actual audio distribution: accented speech, noisy environments, domain-specific vocabulary. A provider that scores 2% WER on LibriSpeech may score 15% on your call-center recordings.

• Additive costs triple your bill. Per-minute pricing hides diarization, PII redaction, sentiment analysis, and custom vocabulary as paid extras. Factor them in before committing.

• Streaming vs. batch pricing gap. Deepgram Nova-3 costs $0.0036/min in batch but $0.0056/min streaming, a 56% premium. If your use case tolerates async processing, use batch mode.

Key Takeaways

• Apple SpeechAnalyzer is a genuine Whisper alternative for macOS 26+ Apple Silicon apps: 2.12% WER, ~3× faster than Whisper Small, with zero model bundle and zero network egress.

• Yap proves the OS-provided-model approach works: 4 MB app, 60 MB RAM, no API keys, no telemetry.

• Cloud STT is cheaper than ever, under $1/1,000 minutes from Groq, under $4 from Deepgram or AssemblyAI, but additive features and streaming premiums can triple the effective rate.

• The right tier depends on your constraints: privacy → on-device; accuracy → cloud; control → self-hosted; flexibility → multi-provider API.

• Always benchmark on your own audio, not the provider's demo set.

Whichever tier you ship, keep the transcription layer swappable. Benchmarking a provider against your own audio is far easier when switching between Deepgram, AssemblyAI and Google is a configuration change rather than a rewrite.

You can find them at Eden AI.

Login to the platform to test it yourself.

FAQ