Repo of the day: Meetily, the meeting minutes that never leave your computer

🔍 What Meetily is: minutes without the cloud

Meetily is a desktop app that records your meetings, transcribes them in real time, and generates a structured summary — decisions made, key points, action items — without a single audio track leaving your computer. It's published by Zackriya Solutions under the MIT license, runs on macOS and Windows (on Linux you build from source), and is today one of the most-followed open source projects in its niche: as I write it has around 26,500 stars and 2,700 forks.

The difference from Otter.ai, Granola or Fireflies isn't in the interface — it's in where the processing happens. Cloud services upload the meeting audio to their servers; Meetily does the opposite: transcription models, recordings and transcripts all stay stored locally. That's why the project describes itself as "GDPR and HIPAA compliant by design" — not because it adds clauses, but because the data simply never leaves the perimeter you control.

repo       Zackriya-Solutions/meetily
stack      Rust + Tauri (desktop) · Next.js (UI) · MIT license
author     Zackriya Solutions
what       AI meeting assistant: local transcription and summaries
requires   macOS or Windows (Linux: build from source); Ollama for summaries
stars      ~26,500 · ~2,700 forks (snapshot as of July 25, 2026)

🔒 Why it matters: data sovereignty as the default

Meetings are among the most sensitive data containers a company has: negotiations, client data, confidential decisions, sometimes health or financial information. Handing that audio to a cloud service moves the compliance risk out of your hands, toward retention and access practices you don't control. For a law firm, a clinic, a financial-services company or a public administration, this is often not a matter of taste but a hard constraint: the audio can't leave. By keeping everything local, Meetily turns data sovereignty into the default behavior rather than an option you have to configure.

There's also a technical detail I appreciate: Meetily records at the system-audio level, rather than joining the call as a participant. No bot with a "Recording bot has joined" banner, no browser extension, no permission to request from the host. For the same reason it works with any platform — Zoom, Microsoft Teams, Google Meet, Webex, even Slack huddles — because it simply captures whatever comes through your speakers and microphone.

⚙️ How it works: Rust, whisper.cpp and Ollama

Under the hood Meetily is a single application built with Tauri: a Rust backend that handles the logic and a Next.js frontend for the interface. Transcription runs locally via whisper.cpp (Whisper models, from `tiny` to `large-v3`) or NVIDIA's Parakeet model in its ONNX build; hardware acceleration is automatic at build time — Metal and CoreML on Apple Silicon, CUDA or Vulkan on Windows and Linux. A built-in audio mixer captures microphone and system audio together, with ducking and clipping prevention, so even hybrid calls stay legible.

The summary is where you decide the trade-off between privacy and model power. The recommended path is Ollama, which runs an LLM locally and keeps the whole pipeline offline: audio becomes text and text becomes a summary without ever touching the network. Alternatively you can plug in your own key (Claude, OpenAI, Groq, OpenRouter) or an internal OpenAI-compatible endpoint — handy for anyone who already has private AI infrastructure. It's the same "local models with Ollama" philosophy I covered for RAG in .NET, applied here to voice instead of documents.

🚀 How to install and try it

On macOS and Windows there's nothing to compile: download the installer from the project's Releases, launch the app — no account needed — and start recording your first meeting. To get fully local summaries too, install Ollama and pull a model: from then on transcription and summarization need no connection. On Linux, or if you want to get your hands dirty, you start from source with Rust and Node.js already installed.

The first run I'd suggest is low-risk: a low-stakes internal meeting, a mid-sized Whisper model and a small LLM on Ollama, just to see what the transcript and the generated minutes look like on your hardware. Only afterward does it make sense to raise the bar — a larger transcription model for accuracy, a more capable LLM for better summaries.

# macOS / Windows: download the installer from Releases (no account)
#   https://github.com/Zackriya-Solutions/meetily/releases/latest

# 100% local summaries: install Ollama and pull a model
ollama pull llama3.1

# Linux or build from source (requires Rust + Node.js)
git clone https://github.com/Zackriya-Solutions/meetily
cd meetily/frontend && pnpm install && ./build-gpu.sh

🏢 Why it matters, for developers and SMBs

For developers, Meetily is also a great architectural reference: it shows how to put together a serious local-first desktop app — Tauri for the shell, Rust for performance, whisper.cpp for transcription — under an MIT license with readable code. You can see exactly what it does, fork it, adapt it, or just borrow the patterns for your own offline tool. In a year when half the trending projects are agents calling cloud APIs, a project that brings inference onto the device is a useful counterpoint to study.

For an SMB, the value is more direct: automatic meeting minutes without shipping the audio to third parties, at a marginal cost near zero because the Community Edition is free and the models are open. For regulated sectors — legal, healthcare, finance, public administration — local transcription isn't a nicety but often the only viable path to adopting AI on meetings without opening a compliance front. It's the same shift I talk about when I cover AI automation in non-IT departments: take a repetitive business process — here, note-taking — and let the machine absorb it, but on your own terms about the data.

⚠️ Limits and caveats before using it

Meetily is solid but it isn't magic, and a few things are worth factoring in before you adopt it. The most obvious is that "local" only truly holds if you stay local: if you pick a cloud LLM instead of Ollama for the summaries, the transcript text does leave the device, and the data-sovereignty guarantee applies in full only with local models. That's a legitimate choice, but one to make knowingly.

Then there's the hardware and maturity side. Local transcription and summarization ask for resources: on a modest machine Whisper's `tiny` size is fast but imprecise, `large-v3` is accurate but heavy, and a GPU noticeably changes the experience. Accuracy, in short, is whatever the model you choose delivers, not a fixed property of the product. Finally, the distribution model is open-core: the Community Edition I'm describing is MIT and free, but there's also a paid PRO version, on a separate codebase, with extra features — worth knowing only so you're clear which edition you're evaluating.

• Local only if you stay local: with a cloud LLM for summaries the transcript leaves the device; with Ollama everything stays offline.
• Linux: no native app, you build from source (macOS and Windows have installers).
• Hardware: local transcription and summarization need resources; a GPU helps a lot.
• Quality = model: accuracy depends on the model you choose (Whisper `tiny` vs `large-v3`, small vs large LLM).
• Open-core: the Community Edition is MIT and free; a separate paid PRO exists — check which one you need.

✅ Where to start

The path I'd suggest is incremental: install Meetily on macOS or Windows, pair it with Ollama and a small model, record a low-stakes internal meeting, and read the minutes it produces. From there you decide the two levers that matter — the size of the transcription model, for accuracy, and whether to keep everything local or lean on an external LLM for summaries — based on how sensitive that specific meeting's data is.

Zooming out, Meetily is a good example of where a slice of applied AI is heading: not everything needs to go through the cloud, and for many Italian SMBs it's precisely the ability to process locally that makes adoption practical rather than theoretical. That's why I watch it with interest, beyond the single app: it's proof that "useful" and "on my device" are no longer a contradiction.

More articles from the blog