# Detto turns meetings into plain markdown files on your own Mac

> Gremble-io/Detto is a macOS app for Apple Silicon that captures meetings, voice memos and system-wide dictation, transcribes on the Neural Engine and refines text on the GPU, then writes plain markdown with YAML frontmatter into a folder you own. It is local by architecture rather than by setting, and the licence is BSL 1.1.

**Gremble-io/Detto** — On-device meeting capture, dictation, and vault-native knowledge layer for macOS. Nothing leaves your Mac.

- Repository: https://github.com/Gremble-io/Detto
- Website: https://detto.app
- Stars: 521 · Forks: 24
- Language: Swift
- License: NOASSERTION
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/gremble-io-detto

## One key, one transcript, one plain file on disk

The tagline in the README is the whole interaction model: hold a key, speak, release, text appears. Meetings, voice memos and system-wide dictation, with the claim that nothing leaves your Mac.

Detto is a macOS app for Apple Silicon. The technical arrangement is specific. ASR runs on the Apple Neural Engine through Parakeet-TDT v3, and text refinement runs on the GPU using Llama 3.2 3B through MLX. After the initial model download, the only network activity is optional Sparkle update checks against a static XML file on GitHub Pages.

That last sentence is the design decision the rest of the project follows from. The README puts it as a philosophy rather than a feature: privacy is architecture, not a toggle. There is no server, no account, and no analytics SDK buried in the dependency tree. A setting that turns data collection off is a promise; a program with no server to send data to is a different kind of assurance.

The output is the other half of the bet. Every transcript lands as a plain `.md` file with YAML frontmatter, described as ready for Obsidian, agents, backlinks and whatever you build next. You own the files, there is no proprietary format and no export step.

The badges at the top of the README set the floor: Swift 6.2, macOS 26 or newer, BSL 1.1, and Apple Silicon required. This is a modern-Mac-only application, not a cross-platform one.

## Why a consultant built it: the vault was there, capture was missing

The Why section is written in the first person, and it explains the product better than a feature list would.

The author is a consultant who built an Obsidian vault as a second brain: structured notes with YAML frontmatter, backlinks, tags and an AI agent layer that processes everything. Client files, meeting notes, action items and daily briefs all flow through that vault. The gap was capture. They are on calls all day and do not take notes, so they needed something that would listen, transcribe, and drop structured markdown into the vault where their agents could pick it up, pull out action items, update client files and connect the dots.

The competitive analysis is blunt: Otter, Granola and Fireflies all lock your data in their cloud, their format and their walled garden. None of them output plain markdown, none feed into an agent workflow, and none work offline.

This is the most useful thing about the project to read, because it tells you what kind of user it is for. The target is not someone who wants a transcript in a web app. It is someone who already has a markdown-based knowledge system and needs the front door to be automatic, because the discipline of filing notes by hand is what breaks.

That also sets the bar for a fair evaluation. If you do not already maintain a vault with YAML frontmatter, Detto gives you a folder of markdown files and a local refinement model, which is useful but is not the product's reason to exist.

## Three capture modes with different audio sources

The three modes differ mainly in what they listen to and where the output goes.

Call Capture grabs microphone and system audio simultaneously. The mic channel is labelled "You" and the system channel "Them", which gives channel-based speaker separation rather than relying on a diarisation model to work out who spoke. The app also detects which conferencing app is active, naming Teams, Zoom, Slack, Webex and Google Meet, and tags the transcript metadata accordingly. The result is a structured `.md` file with YAML frontmatter in your vault.

Voice Memo is microphone only, for quick thoughts and notes, and it saves to a separate folder so it does not clutter the meeting transcripts. The format and frontmatter are the same.

Dictation is the system-wide one. You hold a hotkey to record and release to transcribe, and the text is injected at your cursor in whatever app you are in, whether that is Slack, email, a document or a terminal. The hotkeys are configurable, with Left Control, Fn, Right Option, Right Command, Hyper Key and Ctrl+Option+Space listed, plus any custom combination, and there are two activation styles: hold to speak and release to transcribe, or toggle mode with a double-tap to start and a double-tap to stop. A floating pill overlay shows the recording state and a live waveform.

The dictation design has a two-phase structure that explains the speed. It emits a transcript immediately, then refines in the background. That is what makes it feel instant while still producing clean output, and it is the same idea as pre-warming the GPU cache during dictation so that refinement starts the moment you release the key.

The channel-based split in Call Capture is worth noting as a design choice rather than a limitation. It is cheap and reliable, but it assumes one speaker per side of the call, which is exactly the assumption that breaks in a meeting room with several people on one microphone.

## Client Briefing: the vault is read before the call, not after

The client briefing feature is the most distinctive idea in the project, and it is the one the README argues for most directly with the line that capture without context is just noise.

You point Detto at your vault root and it scans for markdown files with `type: client` frontmatter. The main window switches to a split layout, clients on the left and a briefing panel on the right. Selecting a client shows their key contacts, current priority and upcoming dates, pulled live from the vault file, plus a notes field for jotting pre-call context.

When you record with a client selected, the transcript includes a `## Context` section containing the structured client data and your notes, and the output file is renamed to include the client name. Most-used clients float to the top. With no client selected, the panel shows a generic call form with attendees, topic and notes, and that also goes into the transcript's context section.

The configuration is a single file in the vault root:

```yaml
clientsPath: Clients
clientType: client
sections:
  contacts: Key Contacts
  priority: Priority Item
  timeline: Operational Timeline
```

The defaults work out of the box if your client files live in `Clients/` with those headings, and the README says you can change the paths and headings to match whatever structure your vault already uses. That last point is the important one for adoption. The scanning convention is a contract with your existing notes, and the file lets you meet the app halfway instead of restructuring a vault you have used for years.

## Local refinement and its honest limits

Raw speech recognition output has rough edges: missing capitalisation, no punctuation, the occasional word-order glitch. Detto addresses that with Llama 3.2 3B in 4-bit quantisation running on the GPU through MLX. The model downloads automatically on first launch, about 2GB, and is cached after that.

The README is unusually straight about the trade-off. Small local models will not match a frontier cloud model on polish, and that is the price for owning your voice. A 3B model rewriting a transcript is doing a much more constrained job than a frontier model, and the result is capitalisation and punctuation repair rather than summarisation, but the constraint still shows: the failure modes of a small model are different from a large one, and the occasional word-order glitch in the raw output is exactly the kind of thing a 4-bit 3B model can make worse rather than better.

Two architectural details are worth keeping in mind. First, the two-phase dictation design means the text appears before the refinement, so the refinement can be wrong without blocking you. Second, the pre-warming of the GPU cache during speech means the first word of a dictation session is not paying a cold-start cost, which is the difference between feeling instant and feeling like a request to a service.

The repository layout shows that this is a substantial application rather than a script: an `ARCHITECTURE.md`, a `CHANGELOG.md`, a `CONTRIBUTING.md`, a `PRIVACY.md`, a `ROADMAP.md`, a `SECURITY.md`, a `Detto/` directory with the Swift sources, `ExampleVault/` and `ExampleVocabulary/` sample directories, and a `scripts/` directory. The presence of an example vocabulary directory suggests the refinement step can be steered with domain terms, which is the standard way to improve a small model's output for a specific field.

## Licence, updates and the gap between a badge and a file

The licence is where the README and the repository metadata disagree, and the disagreement is worth resolving before you install anything.

The badge at the top of the README says BSL 1.1, the Business Source License. The repository is recorded as carrying a custom licence that GitHub cannot classify, with a `LICENSE` file at the top level. The BSL is a source-available licence, not an open source one: the code is available under its terms, and the terms change to an open source licence after a set period. The `LICENSE` file is the authoritative text, and it is the file to read if you intend to redistribute the app or build on it, not the badge.

The privacy posture is documented separately in `PRIVACY.md`, and `SECURITY.md` sits alongside it, which is a reasonable arrangement for a project that handles microphone and system audio.

On maintenance, the repository is not archived and the last push was on 2026-07-22. The three listed releases are v2.0.6 on 2026-07-22, described as audio and memory usage improvements, v2.0.5 on the same day, an in-app version update fix, and v2.0.4 on 2026-06-10. Two releases on the same day tells you the maintainer ships quickly and fixes small things immediately.

Updates arrive through Sparkle, and the check goes against a static XML file on GitHub Pages, which keeps the update path consistent with the no-server claim. There is also an `ARCHITECTURE.md` and a `ROADMAP.md`, which are useful for judging where the project intends to go, and the `ExampleVault/` directory gives you a working sample to point the app at before you risk your real notes.

## Conclusion

Adopt Detto if you keep notes in an Obsidian-style vault of markdown files with YAML frontmatter and you need meeting capture that never leaves your Mac, because the output is a plain file rather than a vendor format and the models run on the Neural Engine and GPU. Do not adopt it if you are not on Apple Silicon with macOS 26 or newer, if you need a shared transcript other people can open in a browser, or if the BSL 1.1 terms conflict with how you intend to redistribute the app. Before you rely on it, read the LICENSE file rather than the badge, check that your vault's frontmatter uses the `type: client` field the client briefing scans for, and confirm the first-launch model download of about 2GB is acceptable on your connection.

## FAQ

### Does Detto send my meeting audio anywhere?

The README states that after the initial model download the only network activity is optional Sparkle update checks against a static XML file on GitHub Pages. ASR runs on the Neural Engine and refinement runs on the GPU locally, and there is no server and no account.

### What format are Detto transcripts saved in?

Plain markdown files with YAML frontmatter, written into a folder you choose. The README describes them as ready for Obsidian, agents and backlinks, with no proprietary format and no export step.

### How does Detto tell the app which client a call is about?

You point Detto at your vault root and it scans for markdown files with `type: client` frontmatter, then shows contacts, priority and upcoming dates from the file. The paths and headings are configurable in a `.detto.yaml` file in the vault root, and selecting a client embeds a `## Context` section into the transcript and renames the output file.

### What are the system requirements for Detto?

The README badges list macOS 26 or newer, Apple Silicon required, and Swift 6.2 as the language version. The refinement model is Llama 3.2 3B in 4-bit quantisation and downloads automatically on first launch, roughly 2GB, cached after that.

### Which hotkeys does Detto's dictation support?

The configurable options listed are Left Control, Fn, Right Option, Right Command, Hyper Key, Ctrl+Option+Space, or any custom combination. There are two activation styles, hold to speak and release to transcribe, or toggle mode with a double-tap to start and a double-tap to stop.

## Sources

- [Gremble-io/Detto on GitHub](https://github.com/Gremble-io/Detto)
- [Issues](https://github.com/Gremble-io/Detto/issues)
- [Project website](https://detto.app)
- [README](https://github.com/Gremble-io/Detto/blob/main/README.md)
- [Releases](https://github.com/Gremble-io/Detto/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/gremble-io-detto