https://reddit.com/link/1uobt7v/video/q4jhs80prgbh1/player

Hey r/macapps, I'd like to introduce you to EnviousWispr, a Wispr Flow-like dictation + polishing solution that is free, private and works offline.

Trust Factor:

Linkedin

Privacy Policy

Terms of Service

Open Source Github

Problem:

Voice-to-text with AI cleanup is not a new idea anymore. Wispr Flow has done an incredible job making people aware of the workflow: hit a shortcut, talk naturally, get cleaned-up text back. I knew I needed that in my life. That said, I did not love the idea of handing all of my personal dictations to a cloud service nor did I want to pay. I found a few free local options but none met the quality standards I sought.

Four months and 400+ hours later, I'm excited to share EnviousWispr with all of you. Blazing fast and accurate transcription and AI polish runs on your Mac without the need for internet. No account. No subscription. Free Forever. Open Source. Optional "bring your own API key" for OpenAI/Gemini cloud polishing provided for no additional cost.

Comparison

Wispr Flow is the obvious leader in the space with Superwhisper at its heels. They support multiple OS systems and are feature rich but come with a monthly subscription and cloud only transcription and polishing. Superwhisper is expanding into local dictation and polishing but gatekeeping the best models behind paywalls.

FluidVoice is another great open-source app from this sub, and they also ship a trained local model. We've built our apps to serve slightly different audiences and I see both co-existing depending on people's needs and preferences.

The category is getting crowded, which is good. It means the workflow is real. I think the next question is whether people can get that workflow without being pushed into a paid cloud product by default.

Pricing

- Price: Free Forever

- Subscription: none

- Account Creation: none

- License: GPLv3

Download: https://enviouswispr.com

How it works

Instead of overwhelming you with a dozen engine choices, I benchmarked the options and landed on two clear winners. Both are fully optimized for EnviousWispr to squeeze the absolute most out of Apple Silicon:

https://preview.redd.it/21b0jbsyxcbh1.png?width=2048&format=png&auto=webp&s=c7994e793f5440e9b1834a18e1e628a570aadfc9

Parakeet v3: The winner for everyday English and European dictation. It runs directly on the Apple Neural Engine and transcribes in subseconds providing near instant transcription.

Whisper Large v3 Turbo: The winner for international breadth. It covers 99 languages and cuts through the toughest background audio or accents.

The Three Local AI Polishing Options

Apple Intelligence: The out-of-the-box default

Natively, EnviousWispr defaults to using Apple Intelligence for the polishing layer. No additional download needed. It is perfect for users that just want to get up and running fast and are happy as long as the basics are covered (removing uhms/ahs, fixing light grammar and properly formatting dates/times/emails/currency etc). Note: Apple Intelligence polish requires macOS 26 (see caveats).

EG-1: The Custom Tuned Local Powerhouse

EG-1 is my own custom offline AI model, fine-tuned specifically for dictation cleanup. It takes about 2.9 GB on disk, then runs locally on your Mac. No internet required. It's designed to match the power of Wispr Flow's cloud-based AI polishing. It addresses the gaps Apple Intelligence wasn't able to fill: reliably structuring lists, splitting text into natural paragraphs, and reliably recognizing self-corrections.

One note on licensing: the app is open source under GPLv3, but EG-1 itself ships under its own license. It's free to use in the app and for personal, research, and benchmarking use, but unlike the app code it isn't licensed for redistribution or reuse in other products.

Ollama: Raw models for testing

Given the breadth of local models on Ollama, fine-tuning the prompts per model has proven to be a unique challenge. I recommend 3B or higher models if you want to try the raw models.

Performance Benchmarks:

I built a 1,890-case test set from real dictation cleanup examples, kept a separate 900-case holdout I did not tune against, and ran the same cases through both local and cloud polish options each with their own custom prompts. These prompts were iterated upon to get the best possible scores.

My benchmark, not an independent review: EG-1 passed 93.7% of the 1,890 cases. GPT-5.4-mini was 83.8%. Gemini 3.5 Flash was 92.6%. Same cases, same judge.

https://preview.redd.it/t9avkasyxcbh1.png?width=2000&format=png&auto=webp&s=c5a005869f16993294ea054ae22d607e93ad66b0

Both Apple Intelligence and my own custom tuned model EG-1 ended up performing way better than expected. Apple's on-device model should also keep improving with each macOS release. The eval harness and prompts are public in the repo; the test cases are my own dictations, so those stay private. Personally, EG-1 is my recommended local cleanup engine in the app given its speed and accuracy at AI polishing.

Full Feature List

https://preview.redd.it/vxl4wqsyxcbh1.png?width=2048&format=png&auto=webp&s=23ecab776764660071868542896ca7b904e53ce2

- Local transcription on Apple Silicon via Parakeet or WhisperKit

- 99 languages supported

- Offering both faster live transcription or more accurate batch processing

- Audio Engine kept warm to enable fast short dictations

- Designed to hear you even when you whisper

- Local AI Polishing through EG-1 or Apple Intelligence

- Deterministic cleanup for numbers, dates, money, emails, phone numbers, and times etc

- Optional Ollama, OpenAI, or Gemini polish

- Optimized for both regular mic or bluetooth

- Double tap record to go from push to talk to toggle

- Local History Tab of all recordings

- Custom words with confidence-aware matching that catches near-misses

- Prebuilt custom Word Packs + import Contact Names with 1 click

- Speak the full emoji library

- Remembers where your cursor was, even if you switch apps mid-dictation

- Restores your clipboard after pasting

- Dictations up to an hour

- Dark & Light Mode

- Works offline

- Open source under GPLv3

Caveats, so nobody wastes a download

- Apple Silicon only, M1 or newer

- macOS 14 Sonoma or newer

- No Intel build

- Parakeet transcription (mandatory, English + 25 European languages): about 460 MB on disk

- WhisperKit transcription (optional, 99 languages): about 1.6 GB on disk

- EG-1 polish (optional): about 2.9 GB on disk

- EG-1 is most comfortable on Macs with 16 GB of memory but open to feedback on 8GB memory MacBooks.

- Apple Intelligence polish requires macOS 26 or later

I would just love candid feedback!

- Does the hotkey-to-paste workflow feel fast enough?

- Does the cleanup help, or does it over-edit?

- Where does setup feel confusing?

- What apps does it break in?

- What would make you trust it as a daily driver?

If you try it, I'd love the honest version: accuracy, speed, cleanup quality, setup friction, or where your current dictation app still beats it.

I ran a 1,890-case dictation-polish benchmark across four polishing paths: Apple AFM on macOS 26, OpenAI GPT-4o with a rewritten v6 polish prompt, Gemini 2.5 Flash with the same prompt, and FluidVoice's Fluid-1 custom local polishing model.

The test was deliberately naked: no regex repair layer, no custom deterministic cleanup, and no app-specific fixes after the model returned text. The goal was to measure the raw polish model, not the full product experience.

Top-line result: cloud models were still best when given a strong prompt. GPT-4o passed 91.6% of cases and Gemini passed 90.1%. But local models are not a joke. Stock AFM passed 65.7%, and tuned local Fluid-1 reached 74.8%. Fluid-1 also had the lowest false-positive rate on trap cases.

My read: local polish is already viable for privacy-first, offline, and cost-sensitive workflows. It is not yet as robust as cloud polish for complex transformations, especially topic shifts, list formatting, and deeper self-corrections.

https://preview.redd.it/2t17ew07foah1.png?width=1979&format=png&auto=webp&s=ae9bc30e336637f9340a86e0941ef3cff12ec6e8

Figure 1. Overall green pass rate. Green required behavior correctness, meaning preservation, and clean output.

What I mean by polish

This benchmark is not testing speech recognition. It starts after speech-to-text has already produced a raw transcript. The polish step turns rough spoken text into something closer to what the user meant to type.

Examples include filler removal, false-start cleanup, self-correction resolution, punctuation/capitalization, list formatting, named-entity preservation, emoji retention, anti-hallucination behavior, and prompt-injection passthrough.

System	Type	Green pass	Yellow near-clean	Red fail	Median latency
GPT-4o v6 prompt	Cloud	91.6%	3.5%	4.8%	764 ms
Gemini 2.5 Flash v6 prompt	Cloud	90.1%	4.0%	5.9%	486 ms
FluidVoice Fluid-1	Tuned local	74.8%	4.3%	20.9%	845 ms
Apple AFM	Built-in local	65.7%	6.1%	28.3%	755 ms

The big deployment advantage for AFM is not raw quality. It is that the OS path is already there: no separate model download, no per-call API spend, no network dependency, and no bandwidth cost just to install a local model. It did not win the quality test, but its economics and privacy profile are excellent.

The important local-vs-local comparison is AFM vs. Fluid-1. Fluid-1 beat stock AFM by 9.1 percentage points overall, which is a strong sign that custom local tuning can materially improve polish quality beyond an out-of-the-box on-device model.

https://preview.redd.it/tftcnv07foah1.png?width=1979&format=png&auto=webp&s=b697f4c6b6afefc2a45e711bd196d39fff4e4c8c

Figure 2. Green/yellow/red outcome distribution by system.

The prompt-engineering result

I also included one retired comparison point: GPT-4o with the older/original prompt. Same model, old prompt: 69.6%. Same model, rewritten v6 prompt: 91.6%.

That is a 22.0-point jump without changing the model. The clearest result in the benchmark is that polishing quality is extremely sensitive to prompt design.

This also means the benchmark should not be read as a permanent ranking of model capability. It is a snapshot of these systems under these exact prompting and configuration conditions.

https://preview.redd.it/3ygwjz07foah1.png?width=1678&format=png&auto=webp&s=0373753f1ba2f27bf63802442b9e57507c4a72a7

Figure 3. GPT-4o moved from 69.6% to 91.6% with a prompt rewrite only.

Where local models already look strong

AFM was genuinely solid at restraint and everyday cleanup: 95.9% on minimal-edit cases, 90.0% on onset markers, 88.0% on named-entity preservation, 87.0% on anti-hallucination, and 86.0% on punctuation/capitalization.

Fluid-1 looked like a tuned local model should look: meaningfully stronger than stock AFM overall, with specific wins on punctuation/capitalization, minimal edit, verbatim passthrough, named-entity preservation, and emoji retention.

Trap cases were especially interesting. The big local gap is not mainly restraint. It is performing the right transformation when the input actually needs one.

Case type	Apple AFM	GPT-4o v6	Gemini v6	Fluid-1
Positive cases, should transform	58.2%	91.2%	88.7%	66.5%
Trap cases, should not transform	89.0%	91.0%	92.0%	92.7%
Mixed multi-behavior cases	68.2%	93.8%	91.8%	84.9%
Passthrough/instruction-safety cases	78.0%	93.0%	95.0%	91.0%

https://preview.redd.it/ilu2nv07foah1.png?width=2045&format=png&auto=webp&s=624e5fa8cb9fc30a236fa61ed8b39a5f70cf7275

Figure 4. Local systems were much closer on restraint than on active transformation.

Where local models struggled

The hardest local failure mode was structure. Topic shifts were the clearest split: GPT-4o scored 88.0%, Gemini scored 85.0%, AFM scored 12.0%, and Fluid-1 scored 1.0%. Often the local outputs cleaned the sentences but failed to separate distinct subjects into paragraphs.

List formatting was also hard. Even the cloud models only landed around the mid-70s, which makes it the weakest shared category for the strongest systems. AFM and Fluid-1 were lower, around 50-55%.

Self-correction is where tuning clearly helped. AFM scored 49.0%; Fluid-1 scored 79.5%; the cloud models were around 90-92%.

Skill	Apple AFM	Fluid-1	GPT-4o v6	Gemini v6
Topic shift	12.0%	1.0%	88.0%	85.0%
List format	49.5%	54.5%	76.5%	73.5%
Self-correction	49.0%	79.5%	91.5%	90.0%
Emoji retention	11.0%	88.0%	98.0%	96.0%
Grammar fix	81.0%	46.0%	92.0%	74.0%

One thing I would not do is generalize "local models are bad at X" too broadly. AFM was bad at emoji retention, but Fluid-1 was good. Fluid-1 was weak on grammar fixes, but AFM was good. The failure modes are model-specific.

https://preview.redd.it/oepd4w07foah1.png?width=1977&format=png&auto=webp&s=7098d51d8adc123915f7f6fce166dc975c06061a

Figure 5. Category-level heatmap across all 14 benchmark skills.

Over-eager editing

Trap false positives measure how often a model applied a behavior when it should have left the text alone. Fluid-1 was the most restrained system in this cut, with a 4.0% false-positive rate.

System	Trap false-positive rate
Apple AFM	10.0%
GPT-4o v6	9.0%
Gemini v6	7.0%
Fluid-1	4.0%

https://preview.redd.it/d3227w07foah1.png?width=1779&format=png&auto=webp&s=3d8b62aa8ecf71c8c7e3b485d1022fc6a3a07dc5

Figure 6. Trap false-positive rate. Lower is better.

Latency was not the deciding factor

Representative latency was good across the board. Gemini was the fastest by median at 486 ms. AFM was 755 ms, GPT-4o v6 was 764 ms, and Fluid-1 was 845 ms. Every system had a p95 under 2 seconds.

There were some huge max-latency outliers, especially on the cloud side and Fluid-1, but those looked like isolated retry/backoff/cold-start events rather than typical performance. Median and p95 are the numbers I would use for a practical comparison.

https://preview.redd.it/asswnv07foah1.png?width=1978&format=png&auto=webp&s=843c0293ce8ab7d10ef0c673081c26de71ee919c

Figure 7. Median and p95 latency per polish call.

Practical takeaways

Cloud polish is still the quality ceiling. With a strong prompt, GPT-4o and Gemini both cleared 90% on the full working set and stayed relatively flat across length buckets.

AFM is a viable local intermediary, not a cloud replacement. Its 65.7% naked score is not high enough to call it equivalent to the best cloud path. But it is free from per-call API cost, requires no separate model download, avoids network dependency, and is already strong on a meaningful set of everyday polish tasks.

Fluid-1 shows the value of tuning local models. It beat AFM overall, was much stronger on self-correction, and was the best system for avoiding trap false positives.

The best user experience is probably choice. Use local when privacy, cost, and offline behavior matter. Use a bring-your-own-key cloud path when quality matters most. Let the user decide where they sit on that tradeoff.

Disclosure: I work on EnviousWispr, so treat the product implications with that context. I included FluidVoice/Fluid-1 because it is a real local-first competitor and because it performed well enough to make the local-model story more interesting, not less. My practical recommendation is not "use one app." It is to choose tools that expose the model tradeoff clearly: AFM-style local polish when you want free/private/offline, tuned local models like Fluid-1 when you want stronger on-device polish, and BYOK OpenAI/Gemini when you want the highest raw quality.

Caveats

1. The 1,890 cases were the working set used during prompt iteration. A sealed 900-case holdout exists but was not run for this benchmark.

2. AFM and Fluid-1 were not given the same prompt-rewrite effort as the cloud paths. The cloud results include a large prompt-engineering investment.

3. This was a naked model test. Real products usually add deterministic cleanup, formatting, safety checks, vocabulary handling, and fallback behavior.

4. The judge was an LLM judge, not external peer review or human panel scoring.

5. The benchmark is English-only and focused on dictation polish, not speech recognition.

6. I am not making claims about Fluid-1's underlying training data or architecture. I only tested the outputs produced by the local Fluid-1 path available for comparison.

Bottom line

Local polish is already good enough to matter. Stock AFM is not at cloud quality yet, but it is useful, free to run locally, and strong enough to justify local-first modes. Tuned local models can clearly push quality higher. Cloud models still win when complex transformations matter, especially with careful prompting.

The future I see is not "cloud wins" or "local wins." It is hybrid: local by default, cloud when needed, and enough transparency that users understand the tradeoff.

I build a macOS dictation app. The last step in the pipeline is a comprehensive polish pass. It cleans filler, fixes punctuation, resolves self-corrections, and then pastes the text. On macOS 26, that polish can run fully on-device through Apple's Foundation Models framework (the ~3B "Apple Intelligence" model).

The stock on-device model struggles with one specific thing: self-correction. If you change your mind mid-sentence, "send it to John, actually Jane" should become "Send it to Jane." The stock model often keeps the abandoned wording or picks the wrong name. A competitor (FluidVoice) ships a fine-tuned Gemma and handles this well, so I wanted to see if fine-tuning Apple's own on-device model could close the gap.

While I do not have a formal machine learning background, I approached this fine-tune with strict architectural rigor. I designed the validation pipeline, dataset, and mechanical guardrails, utilizing Claude Code to accelerate the implementation. Here is what the data showed.

What I built

• A LoRA adapter (rank 32, ~67M trainable params on the 3.2B frozen base) using Apple's official adapter training toolkit.
• Trained on my own labeled dictation data (~2,000 raw to cleaned pairs), under the exact prompt the app uses in production. Training under a different prompt than what you ship makes the adapter worse. That was an early mistake worth flagging.
• Trained on an RTX 4090 (24GB) and validated on an M4 Pro Mac.

How I measured it:

• The baseline: The stock Apple model using identical prompts and inputs.
• The test set: I held back 15% of the data during training. I only report on these never-seen cases. Full-corpus numbers look better but include memorized data, which is useless here.
• The grading: I used an ensemble of 12 LLM judges. They graded on meaning (pass, weak, fail) instead of exact string matches. They also ignored numbers, dates, and emojis since my app handles those deterministically in code.

The improvement (held-out, never-seen cases)

• Spoken self-correction resolved correctly: 13% to 86%
• General polish (punctuation, homophones, structure): 66% to 83% (19 of 29 held-out cases)
• Realistic multi-behavior paragraphs: 63% to 84% (27 of 43 to 36 of 43)
• Regressions were few, but not zero. A small number of held-out cases the stock model already passed came out weak or fail after tuning. These were mostly emoji and other deterministic-layer edge cases my app handles outside the model anyway.

The latency cost Stock model versus tuned adapter, both timed on-device on the same Mac, 20 phrases, warmed up:

• Short dictations: +82 ms (+13%)
• Medium: +248 ms (+31%)
• Long: +602 ms (+52%)
• Overall: 846 ms to 1,140 ms, representing a +295 ms (+35%) tax per polish.

The latency tax scales with length. I did not compile the adapter's built-in draft model (the speculative-decoding helper), so this is the unaccelerated number. Compiling it may narrow the gap, though I have not measured that yet.

Honest caveats

• Small held-out sample on the self-correction set (15 cases).
• ~1,560 training examples, 3 epochs, no hyperparameter search. We paused here intentionally.

The wall To actually ship a custom adapter to users, Apple requires a managed entitlement. When I went to request it, the page now reads, verbatim: "We are no longer accepting entitlement requests. The Foundation Models framework adapter API is not compatible with macOS, iOS, iPadOS, or visionOS 27 and later." The adapter toolkit is marked end of life at version 26. So this path is closed for me. I can train and test locally, but I cannot obtain the deploy entitlement needed to ship this adapter to users.

Honestly, I am not that bummed. At WWDC26 earlier this month, Apple introduced a bring-your-own-model path via the new LanguageModel protocol. You can run your own tuned model on-device through Apple's framework with no Foundation Models adapter entitlement gate.

That is the durable version of this experiment and where I am headed next. The adapter was a fun, disposable proof that a small fine-tune meaningfully moves Apple's on-device model on a real task.

(Note: All compute was local on the 4090 plus the Mac, and judging used an existing Claude subscription, resulting in $0 marginal API spend.)

Question for the sub: For the macOS 27 bring-your-own-model route, would you start from a small fine-tuned Gemma, Qwen, or Llama, or something else? I am curious what people are seeing for on-device, polish-style rewriting tasks at ~3B.