Murmure Dictation Review

Murmure 1.11.3 is worth installing if you want free, offline desktop dictation and will teach it technical vocabulary. On a 19.817-second synthetic developer sample, the dictionary improved names but introduced a false positive; six targeted entries plus ordered formatting rules fixed the terms and file path, with only the final period missing. Skip it if you want zero setup or managed support.

Murmure Dictation Review: The Short Verdict

Murmure is a desktop dictation app for Windows, macOS, and Linux. Hold or toggle a shortcut, speak, and its bundled Parakeet model turns the recording into text on your CPU. A dictionary and ordered replacement rules can correct the result before Murmure pastes it into the active application. An optional LLM stage can run locally or send the transcript to an OpenAI-compatible server. That last choice changes the privacy boundary, even though speech recognition itself remains local. The Murmure homepage listed version 1.11.3 and a single free, open-source offering when checked on September 14, 2026.

The verdict is positive, but narrow: Murmure is a good fit for a builder who values local transcription enough to configure the last mile. It is not magic vocabulary recognition. The raw model handled common technical language in the repeatable sample, but a useful result required deciding which mistakes belonged in the dictionary and which belonged in formatting rules.

One naming warning matters before download: Murmure at murmure.app is the product reviewed here. Murmur on Microsoft Store, MurMur Voice-to-Text, Murmur for macOS, and Murmur AI are separate products.

Who Murmure Is For, and Who Should Skip It

Murmure is for desktop users with stable, recurring vocabulary: project names, product names, commands, paths, and phrases that are worth encoding once. It is especially sensible when audio must not be uploaded and when a little configuration is cheaper than correcting the same terms every day.

Pricing and product facts in this shortlist were checked on September 14, 2026.

Pick Murmure when the work happens across an editor, issue tracker, browser, chat app, and terminal, and the same troublesome vocabulary follows you between them. Its insertion modes cover ordinary Ctrl+V, terminal-style Ctrl+Shift+V, and simulated keystrokes. The tradeoff is owning the setup.

Pick Dictare when the goal is not general prose but voice control of Claude Code, Codex, Gemini CLI, Aider, Pi, or another command-line agent. Dictare's live site lists macOS and Linux, local Whisper or Parakeet, an MIT license, and no subscription. It is the sharper specialist for that workflow, but it is not the Windows alternative. See the site's Dictare pricing analysis and the broader guide to voice-controlled AI coding agents.

Pick Windows voice typing if installation and configuration are bigger problems than cloud processing. Microsoft documents Windows+H as the shortcut and says voice typing requires internet access because it uses Azure Speech services. Windows voice access is a separate on-device feature for controlling the PC and authoring text, which is worth evaluating if offline operation matters but Murmure feels too involved. Microsoft explains the distinction.

Pick Apple Dictation if you are on a Mac and want the operating system's built-in path. Apple says it works wherever you can type and that Keyboard settings disclose whether general Dictation is processed on-device. It lacks Murmure's explicit dictionary-to-regex correction stack, but it wins on setup friction. Apple's Dictation guide is the source of truth for the installed macOS version and language.

Skip all four as a procurement shortcut for clinical deployment. Murmure includes Medical vocabulary and prompt presets, but a preset is not evidence of clinical validation, an organizational security agreement, or an EHR support model. A specialist product such as Dragon Medical One is built around clinical documentation and professional medical vocabulary. The right choice still depends on the organization's jurisdiction, security review, integrations, and contract.

Murmure Parakeet Dictation: Raw Output First

Murmure uses NVIDIA Parakeet TDT 0.6B v3 to convert 16 kHz mono audio into text locally, then applies any enabled post-processing. The raw pass matters because an LLM can make a weak transcript look polished while quietly changing its meaning. Testing the recognition layer first shows whether a name was heard incorrectly, formatted incorrectly, or both. Murmure's transcription documentation lays out that order.

The repeatable sample used here was deliberately unfriendly to generic dictation:

Project Kieirra uses the NovusFlow adapter. Open slash opt slash NovusFlow slash releases slash v three slash worker dot pie. Update the Kubernetes namespace, the PostgreSQL schema, and the Pydantic validator. Replace staging dash west with staging dash east.

It was synthesized with eSpeak NG 1.52 using a US English voice at 145 words per minute and pitch 45, then resampled to a 16 kHz mono, 16-bit WAV. The clip lasts 19.817 seconds and contains 39 words. The test machine was an Ubuntu 26.04.1 x86_64 runner with eight AMD EPYC-Rome virtual CPUs, 15,608 MiB of RAM, and no exposed GPU.

The official 1.11.3 Debian package was 624 MiB and its published SHA-256 checksum matched the downloaded file. The AppImage was 693 MiB and also matched its published checksum. The Debian package could not run in the minimal container without desktop dependencies, so the AppImage was used with isolated display and library scaffolding. That is a headless-runner setup observation, not a claim that a normal Ubuntu desktop needs the same work.

With --no-dictionary, Murmure returned:

Project key reuse the novusflow adapter. Open slash opt slash novusflow slash releases slash v3 slash worker dot pie. Update the Kubernetes namespace, the poster SQL schema, and the Pydentic validator. Replace staging dash west with staging dash east.

The model got Kubernetes and the sentence structure right. It missed Kieirra, NovusFlow casing, PostgreSQL, Pydantic, the file extension, and the spoken path notation. From the first CLI log entry to the transcript was about four seconds, including model load. Dividing 19.817 seconds of audio by roughly four seconds gives about 4.95 times real-time processing on this one CPU runner. That is a machine-specific synthetic result, not support for the vendor's separate speed claim.

This baseline is usable for ordinary prose. It is not ready for a command, release note, or issue where one wrong path segment can waste more time than dictation saved.

The Custom Dictionary Helps, Until It Overreaches

Murmure's dictionary does more than replace matching text after transcription. It boosts candidate terms during Parakeet decoding, then applies spelling correction to low-confidence near-misses. That design can rescue a proper noun before it becomes an unrelated common phrase. The dictionary documentation also warns that a longer list makes the boost weaker and increases false-positive risk.

The first pass supplied eight entries: Kieirra, NovusFlow, Kubernetes, PostgreSQL, Pydantic, staging-west, staging-east, and worker.py. It returned:

Project key reuse the NovusFlow adapter. Open slash opt slash NovusFlow slash releases slash v3 slash worker.py. Update the Kubernetes namespace, the PostgreSQL SQL schema, and the Pydantic validator. Replace staging-east west with staging-east east.

That is meaningful progress. NovusFlow gained its intended casing, worker.py became one token, and Pydantic was fixed. PostgreSQL moved closer but acquired a duplicated SQL. Kieirra still failed. Most importantly, the two similar environment entries interfered with ordinary spoken words: both “staging dash” phrases were pulled toward staging-east before the direction word.

The result validates the vendor's “less is more” warning. A dictionary term is a decoding candidate, not a guaranteed semantic instruction. Two phonetically adjacent entries can compete. Adding more variants is therefore not a safe default.

Murmure 1.11.3 accepts one-word or two-word entries, with at most one space. Letters, accents, punctuation, and hyphens are supported; digits and context-aware entries are not. Once the list exceeds 100 entries, the spelling-correction pass is disabled, although exact matches retain their casing. For a large company glossary, that is a design limit, not a minor footnote.

Formatting Rules Are the Technical-Vocabulary Fix

Murmure formatting rules are deterministic transformations applied before insertion. They support Contains, Exact match, and Regex modes, and they run from top to bottom. That makes them the right layer for a phrase whose desired output is known in advance, especially a file path or a spoken separator. The formatting-rule documentation explicitly assigns multi-word replacements, digits, regex, and voice commands to this layer.

The refined run removed the two competing staging entries and kept six dictionary terms. Five ordered rules handled what recognition alone could not:

• key reuse became Kieirra uses.
• One case-insensitive regex converted the spoken slash and dot sequence into /opt/NovusFlow/releases/v3/worker.py.
• PostgreSQL SQL became PostgreSQL.
• staging dash west became staging-west.
• staging dash east became staging-east.

The resulting transcript was:

Project Kieirra uses the NovusFlow adapter. Open /opt/NovusFlow/releases/v3/worker.py. Update the Kubernetes namespace, the PostgreSQL schema, and the Pydantic validator. Replace staging-west with staging-east

Every intended technical term, environment, and path was present. The only textual difference from the target was the missing final period. Processing again took about four seconds from the first log entry to the transcript.

That does not mean every error deserves a permanent rule. “Key reuse” is a synthetic pronunciation artifact, so a live user should add the replacement only if their own recordings reproduce it. The durable lesson is the separation of responsibilities: let the dictionary bias recognition, then let ordered rules encode exact output.

1. 1

   Record a hard baseline

   Use one fixed sample containing the names, paths, numbers, and corrections that matter in the actual workflow. Save the raw output before enabling any cleanup.

2. 2

   Add only recurring names

   Put compact proper nouns and technical tokens that repeatedly fail into the dictionary. Rerun the same sample and look for new false positives, not just fixed words.

3. 3

   Make exact output deterministic

   Use ordered formatting rules for spoken separators, full paths, digits, and known multi-word substitutions. Rerun once more and compare against the target character by character.

4. 4

   Add an LLM last

   Only after the deterministic path is understood should an optional model handle flexible rewriting. That preserves a clean baseline and makes regressions diagnosable.

Murmure Offline Speech to Text: What Stays Local

Murmure keeps the core audio path on the desktop: it captures a WAV, runs Parakeet on the CPU, applies local corrections, and inserts the result. The vendor says audio is deleted immediately, no transcription is written to logs, and the last five history items live in RAM and disappear when the app quits. There is no account or telemetry. The first-steps guide shows the focused-app workflow and insertion choices.

The minimum hardware story is unusually modest for local speech recognition. Murmure recommends at least 2 GB of available RAM and 1 GB of disk, and says no GPU is required. The optional local LLM is a separate load. Its own documentation recommends 4 GB, 7 GB, or 8 GB of VRAM for progressively larger models and warns that CPU-only inference can be slow.

“Local” still needs a platform-specific installation review. A private model does not remove operating-system permissions, shortcut conflicts, or paste behavior.

Windows Setup Has One Unusual System Risk

Murmure on Windows supports Windows 10 or later and requires the Visual C++ Redistributable. Its global shortcut listener can trigger antivirus scrutiny, and the vendor documents an unresolved case where the listener may prevent Windows from sleeping or hibernating while the app runs. The Windows installation page names both constraints.

That sleep behavior is a valid reason to skip Murmure on a managed laptop until the issue is resolved or the organization accepts the workaround. It is more consequential than an extra installer click.

macOS Setup Needs Three Permissions

Murmure on macOS ships for both Apple Silicon and Intel. It needs Microphone, Accessibility, and Input Monitoring permissions, followed by a restart. The default Ctrl+Space binding conflicts with the macOS input-source switcher, while shortcuts containing Space or number keys may leak characters into the active app. The macOS installation page recommends Ctrl+Option+M, a function key, or a mouse button instead.

For an individual Mac, that is a one-time setup. For a fleet, permissions and shortcut policy become deployment work that the $0 price does not capture.

Linux Is Best on X11, More Manual on Wayland

Murmure on Linux fully supports X11. On Wayland, the user must create operating-system shortcuts that call the binary, and only toggle-to-talk is available because those shortcuts do not expose key release events. The Debian package is built on Ubuntu 24.04 and requires GLIBC 2.38 or later; the vendor points older Ubuntu users to the AppImage. The Linux installation page gives package-specific commands and known issues.

If push-to-talk is non-negotiable on Wayland, this is a hard skip. If toggle mode is acceptable, the CLI integration is explicit and survives reboot once configured.

Murmure Local LLM vs Remote LLM

Murmure LLM Connect is an optional text stage, not part of core speech recognition. It can call local Ollama or an OpenAI-compatible server after transcription and before insertion. Four saved modes can each use a different provider, model, system prompt, and user prompt. Translation, Medical, Development, and Voice Dictation presets are included. The LLM Connect documentation also supports applying a saved mode to selected text.

The privacy distinction is simple:

• No LLM: audio and transcript processing stay on the machine.
• Local Ollama: Murmure sends transcript text to a model server on the local machine or local network endpoint you control.
• Remote provider: core audio recognition stays local, but the transcript text and prompt go to the configured server. That server's retention, billing, access controls, and jurisdiction now matter.

The optional-model test kept those layers separate. First, the baseline transcript was sent directly to Ollama 0.34.0 with qwen3.5:0.8b, thinking disabled, and temperature set to zero. Ollama reported 5.005 seconds total on CPU. The model fixed the full file path, PostgreSQL, Pydantic, and both staging environments, but it left “key reuse” and the first lowercase “novusflow” untouched. The deterministic rule stack therefore produced the better result for this stable vocabulary.

The OpenAI-compatible path exposed another tradeoff. Murmure sent the selected transcript to stock Ollama's compatible endpoint, but this small-model run continued for 32.323 seconds and ended with HTTP 500 rather than replacement text. Routing the same Murmure request through a loopback compatibility bridge that disabled thinking and set temperature to zero returned the partial correction 4.769 seconds after the trigger.

That bridge was a diagnostic, not a recommended production component. It proves that the remote protocol path was exercised and that server defaults can change the outcome. It does not prove that every OpenAI-compatible provider will fail, nor that every endpoint needs those settings. It also did not send text to an external provider, so external latency, cost, retention, and confidentiality were not tested. In the headless X11 test environment, the returned text pasted at the cursor instead of replacing the selection, so this run does not claim a successful everyday Transform UI test.

For predictable technical vocabulary, rules win. Use an LLM when the task genuinely requires flexible rewriting, translation, or restructuring, and accept that it can omit a correction, add unwanted wrapper text, or move data across a new boundary.

The Local API Is Useful but Narrow

Murmure exposes an experimental HTTP endpoint for automating file transcription while the app is open. It listens on localhost:4800 by default and accepts multipart WAV uploads at POST /api/transcribe. The Local API documentation includes curl, JavaScript, and Python examples.

The constraints keep it a workstation integration, not a shared transcription service: WAV only, 100 MB maximum, no streaming, sequential requests, localhost or 127.0.0.1 only, and CORS disabled. The dictionary is applied automatically, and language remains auto-detected.

This is enough for a local script that drops meeting clips or voice notes into the same correction stack. It is not an API for concurrent users, browsers, remote workers, or live captions. Building those capabilities around it would change the security and operations model.

Murmure Pricing: The Only Tier Is $0

Murmure had one tier when verified on September 14, 2026: the free, open-source application. There was no paid plan, account, usage allowance, trial clock, or separate commercial feature tier on the vendor page.

The computed software cost is $0 per seat per year and $0 per 1,000 dictated words. Those figures are mathematically exact but economically incomplete. A ten-person deployment still carries permission setup, shortcut policy, vocabulary maintenance, endpoint testing, and user support. Murmure does not hide a subscription; it shifts the buyer's decision from license cost to operational ownership.

There is no subscription break-even to calculate against Murmure itself. The useful break-even is time: if a small dictionary and a handful of rules remove recurring corrections, setup can pay back. If every speaker, project, and environment needs different rules, the ongoing maintenance can exceed the saved keystrokes even at a $0 software price.

The Real Limitations

Murmure has eight limitations that should change a buying decision.

1. The Dictionary Can Make a Transcript Worse

The eight-entry test corrected several terms but turned two “staging dash” phrases into staging-east west and staging-east east. The documentation warns about false positives, and the test reproduced one. Similar-sounding entries need to be introduced one at a time and tested against the same sample.

2. Large Dictionaries Lose a Correction Stage

Above 100 entries, Murmure disables its spelling-correction pass, although exact matches keep their casing. That makes the dictionary a poor home for an entire organization glossary. Builders need a curation rule, not a bulk import habit.

3. You Cannot Force the Recognition Language

Parakeet automatically detects among 25 supported European languages. The docs say there is currently no way to force one. For short clips, code-switching, or audio that resembles another language, that removes a useful recovery control.

4. Desktop Integration Has Platform-Specific Walls

Wayland has no push-to-talk. macOS needs three permissions and a safer shortcut. Windows may stay awake while the app runs. These are not cosmetic differences. They decide whether the app fits a personal workstation, a locked-down company laptop, or neither.

5. The Documentation Disagrees About Recording Length

The transcription page still states a five-minute maximum and automatic stop. Release 1.10.1 says the old five-minute limit was removed, and the current API page says there is no duration limit beyond its 100 MB file cap. The newer release and API documentation are the better evidence, but leaving the old limit live forces users to reconcile official pages themselves.

6. Optional LLMs Add Variability and a New Trust Boundary

Murmure's local path explicitly targets Ollama, while remote mode delegates behavior to an OpenAI-compatible endpoint. The test produced a clean failure on one stock endpoint configuration and a partial correction when generation settings were controlled. Separately, any external server receives transcript text. A remote LLM can be useful, but it is neither a free accuracy upgrade nor part of the baseline privacy promise.

7. There Is No Paid Operations Layer

The vendor presents no paid plan, managed support tier, administrative console, or service-level agreement. That is coherent for a free AGPL-3.0 desktop app. It is also a reason for an organization that needs contractual support, fleet policy, or a named escalation path to skip it.

8. The API Is Deliberately Local and Sequential

The experimental API accepts one queued WAV workflow on localhost. It does not stream and cannot serve a remote browser or multiple concurrent users. It is a useful integration surface, not production speech infrastructure.

Verdict: Use Murmure When Rules Beat Convenience

Murmure earns a recommendation for privacy-sensitive desktop users with recurring vocabulary and tolerance for setup. Version 1.11.3 handled a repeatable technical sample quickly on CPU, and its combination of decoder-aware dictionary entries plus ordered formatting rules produced the intended names, environments, and full path more reliably than the optional small LLM.

Use this decision rule: install Murmure when all three are true.

1. The operating system and shortcut model fit the workstation.
2. Baseline audio and text should remain local.
3. The recurring correction set is small enough to encode and maintain.

Skip it when any hard requirement points the other way: mobile dictation, zero setup, forced language selection, push-to-talk on Wayland, contractual support, concurrent API service, or remote cleanup without permission to send transcript text.

The most defensible setup is also the simplest: local Parakeet first, a small dictionary second, ordered rules third, and no LLM until a flexible transformation has a clear purpose. That keeps errors visible and the privacy boundary easy to explain.

Frequently Asked Questions

Which AI dictation app is the best?

The best app depends on the constraint. Murmure fits local cross-app desktop dictation with custom rules, Dictare fits voice control of terminal coding agents, and built-in Windows or Apple dictation fits occasional use with less setup.

What is the best medical dictation software?

Choose software whose clinical vocabulary, EHR workflow, security documentation, support, and compliance terms match the organization. Murmure has Medical dictionary and prompt presets, but those presets alone do not establish clinical validation; Dragon Medical One is a named specialist to evaluate.

What is the best free online dictation program?

Google Docs voice typing is a browser-based option in current Chrome, Edge, and Safari. Murmure is free but is an offline desktop application, not an online dictation site.

What's the best free app for dictation?

Murmure is the stronger free choice when local processing and repeatable custom corrections matter. Windows voice typing or Apple Dictation is simpler when the priority is using what the operating system already provides.

Does Windows 11 have built-in dictation software?

Yes. Press Windows+H to start Windows voice typing in a text field. Microsoft says that feature uses online Azure speech recognition and requires internet access; Windows voice access is the separate offline, on-device control option.

How do I dictate instead of typing?

Place the cursor in a text field and start the relevant shortcut. Windows uses Windows+H, Apple Dictation uses the configured Dictation shortcut or microphone key, and Murmure uses a configurable global shortcut before inserting the result into the focused app.

What is the best dictation app for iPhone?

Murmure does not target iPhone. Start with Apple's built-in Dictation, which works anywhere you can type, then evaluate a specialist mobile app only if the built-in vocabulary and workflow are insufficient.

Is Google Docs voice typing free?

Google does not list voice typing as a separately priced add-on in its feature instructions. It is available inside Docs in supported browsers, although an organization administrator can disable it.

What is the best way to practice dictation?

Use a fixed script that contains the hard names, paths, punctuation, and corrections from the actual work. Compare each output to the intended text, change one dictionary entry or rule at a time, and repeat with natural speech before trusting the setup.

Murmur offline speech to text

That search can refer to several unrelated products. This review covers Murmure at murmure.app, the free desktop app using local Parakeet transcription, not Murmur from Microsoft Store or other similarly named services.

Get the AI business workflow audit checklist to decide which parts of an automation should stay local and which can cross a provider boundary.