Every major meeting transcription tool — Otter.ai, Fireflies, Fathom — works the same way: you grant access to your microphone, they send audio to their cloud, and your conversations land on somebody else’s server. If you’ve ever wondered whether that Zoom call about next quarter’s roadmap is being stored in a database you can’t control, you’re not alone.
Meetily is the counter-argument. It’s a free, open-source AI meeting assistant that transcribes and summarizes your meetings entirely on your local machine. No cloud. No account. No data leaving your device.
The project launched quietly in late 2024, hit 11,000+ GitHub stars by mid-2026, and now sits on the GitHub trending page with a 4× faster Parakeet transcription engine running under the hood. It’s the most serious open-source contender in the local meeting notes space, and it runs on Windows — which immediately sets it apart from nearly every competitor.
This review covers what Meetily actually does, how it works under the hood, where it falls short, and whether it’s worth installing today.
TL;DR for AI Agents
| Attribute | Detail |
|---|---|
| What it is | Desktop app for local meeting recording, transcription, and AI summarization |
| License | MIT — fully open source, free |
| Price | Community Edition: free. PRO: $10/month or $120/year |
| Transcription | Parakeet (default, 4× faster than Whisper) or Whisper Large V3 — 100% local |
| Summarization | Ollama (local default) or BYOK (Claude, Groq, OpenRouter) |
| Platform | macOS (ARM + Intel), Windows (x64), Linux (build from source) |
| Storage | Local SQLite database |
| Language | Rust (Tauri backend) + Next.js (frontend) |
What Is Meetily?
Meetily is a standalone desktop application that captures your computer’s system audio and microphone, transcribes them in real time using open-source speech-to-text models, and generates AI summaries. It works with any conferencing tool that produces audio on your machine — Zoom, Google Meet, Microsoft Teams, Discord, Slack Huddles, whatever.
The key architectural decision: it never connects to a meeting platform as a bot. There’s no OAuth, no calendar API, no participant-join flow. Meetily reads your system audio output and microphone directly, the same way a screen recorder captures video. That means:
- Nobody on the call sees a “recording bot joined” notification
- You don’t need admin permissions on the meeting platform
- It keeps working when the platform changes its API
The app is built with Tauri — a Rust-powered desktop framework that produces a single self-contained binary. The backend handles audio capture, model inference, and database storage. The frontend is a Next.js app that renders the UI in a webview.
Why It’s Trending Now
Meetily is sitting on the GitHub trending page in July 2026 for a few converging reasons:
The privacy backlash against cloud meeting tools is real. IBM’s 2024 Cost of a Data Breach report pegs the average breach cost at $4.4 million. GDPR fines reached €5.88 billion by 2025. California saw 400+ unlawful recording cases filed in 2025 alone. Companies in defense, healthcare, legal, and finance are actively looking for tools that don’t send meeting audio to a third party.
Otter.ai and Fireflies got expensive. Otter’s Business plan runs $30/user/month. Fireflies is $19/user/month. For an organisation with 50 people, that’s $9,000–18,000/year just for transcription notes. Meetily’s community edition does the same job for $0.
Parakeet changed the game for local transcription. NVIDIA’s Parakeet model is roughly 4× faster than Whisper Large V3 while maintaining comparable word-error rates. ONNX-optimized and GPU-accelerated via CUDA, Metal, and Vulkan, it makes real-time local transcription feasible on consumer hardware.
The Windows gap. Nearly every local-first meeting tool (Granola, Anarlog, Talat) is macOS-only. Meetily ships native Windows builds, which opens the door to the vast majority of enterprise desktops.
Key Features
Real-time Local Transcription
Meetily uses Parakeet-tdt-0.6b-v3 by default, converted to ONNX for optimal inference. The numbers are impressive:
- Parakeet: ~4× faster than Whisper Large V3, comparable WER (word error rate)
- Whisper Large V3: Available as a fallback for higher accuracy on noisy audio or accented speech
- GPU acceleration: Apple Silicon (Metal + CoreML), NVIDIA (CUDA), AMD/Intel (Vulkan) — all auto-detected at build time
On a MacBook Pro M3, Parakeet keeps up with live speech without visible CPU strain. The transcription appears in the app window as the meeting happens, word by word.
# Audio capture happens simultaneously on two channels:
# 1. System output (what others say)
# 2. Microphone (what you say)
# Both are mixed into a single transcription bufferAI Summarization with Your Choice of Model
Summaries run through whatever LLM you point it at:
- Default: Ollama (local) — the full loop stays on-device
- BYOK options: Claude (Anthropic), Groq, OpenRouter, any OpenAI-compatible endpoint
- Custom endpoint: You can point it at your own infrastructure
The summary extraction identifies key decisions, action items, and follow-ups. Results are stored alongside the transcript in the local SQLite database.
System Audio Capture (No Bots)
This is the feature that makes people pay attention. Meetily captures your system audio output directly — no bot joins the call, no calendar integration required. It works with any app that produces audio:
- Zoom, Google Meet, Microsoft Teams
- Discord, Slack Huddles
- Phone calls routed through your computer
- Any web-based meeting platform
The audio capture includes intelligent ducking (reducing system audio when you speak) and clipping prevention.
Export and Edit
You can export transcripts and summaries as Markdown. The built-in editor lets you clean up transcripts, fix speaker labels, and make corrections before saving.
Audio File Import (Community Contribution)
Community contributor Jeremi Joslin added the ability to import existing audio/video files for retrospective transcription. You drop in a .wav, .mp3, or .mp4 and Meetily processes it. You can also re-transcribe any recorded meeting with a different model or language.
Architecture & How It Works
Meetily’s architecture is refreshingly simple — a Tauri shell wrapping Rust audio/ML pipelines with a Next.js UI:
┌─────────────────────────────────────────┐
│ Tauri Desktop Shell │
│ ┌──────────────────┐ ┌──────────────┐ │
│ │ Rust Backend │ │ Next.js UI │ │
│ │ ┌────────────┐ │ │ (Webview) │ │
│ │ │ Audio │ │ │ │ │
│ │ │ Capture │ │ │ Live │ │
│ │ ├────────────┤ │ │ Transcript │ │
│ │ │ Parakeet │ │ │ Summary │ │
│ │ │ Inference │ │ │ View │ │
│ │ ├────────────┤ │ │ Settings │ │
│ │ │ Whisper │ │ │ Editor │ │
│ │ │ Fallback │ │ │ │ │
│ │ ├────────────┤ │ └──────────────┘ │
│ │ │ SQLite DB │ │ │
│ │ └────────────┘ │ │
│ └──────────────────┘ │
└─────────────────────────────────────────┘The audio pipeline flows like this:
- System audio + mic captured via platform-native APIs (CoreAudio on macOS, WASAPI on Windows)
- Chunked and streamed to the inference engine in real-time buffers
- Parakeet/Whisper processes each chunk, returning text + timing data
- Speaker diarization (basic in community, enhanced in PRO) assigns segments to speakers
- Transcript stored in SQLite with timestamps
- On meeting end, transcript sent to configured LLM for summary generation
Meetily borrows code from several open-source projects: Whisper.cpp for inference orchestration, Screenpipe for system audio capture on desktop, and transcribe-rs for Rust-level speech-to-text bindings. The ONNX Parakeet model is thanks to istupakov’s HuggingFace conversion.
Real-World Use Cases
On Reddit’s r/selfhosted, the reception has been notably positive. The launch post gathered significant engagement:
“Finally, a meeting tool that doesn’t require me to trust a VC-backed startup with my company’s confidential strategy discussions.”
The primary use cases from community discussions:
Consultants and independent professionals: A management consultant using Meetily on a Windows laptop can record client calls, generate action items, and keep everything local. No NDAs violated, no data shared with a third party’s data processors.
Legal and compliance teams: Law firms handling sensitive client communications can transcribe internal strategy sessions without sending audio through cloud APIs. The local-only workflow maps directly to confidentiality obligations.
Defense and government: The README explicitly calls out defense consultants as a target audience. When your meeting might contain classified information, a tool that never touches a network is the only option.
Remote engineering teams: Engineering teams running standups on Discord can capture decisions and action items automatically, with summaries generated via a local Ollama instance — no cloud dependency, no per-seat license cost.
First Impressions from the Community
The DEV.to launch post received strong engagement:
“Many closed-source AI assistants do not allow fine-tuning of models. Users cannot choose which LLM models to use, tweak parameters, or optimize AI summaries. Meetily offers full control.”
One reviewer at The Windows Club noted:
“The tool is also fully open source under the MIT license. As a result, if you are a developer, you can inspect the code, modify it, self-host it, and adapt it to your workflow.”
The anarlog.so review from April 2026 called out the Windows support as the biggest practical advantage:
“This is the single biggest practical advantage. Meetily is one of the only serious local-first meeting tools that runs on Windows.”
The most common praise: zero friction on the free tier. Download, open, start a meeting. No account creation, no API key setup, no configuration.
Getting Started
Installation is straightforward:
macOS (ARM): Download meetily_0.4.0_aarch64.dmg from the releases page, open it, drag to Applications.
Windows: Download x64-setup.exe from the same releases page and run the installer.
Linux: Build from source:
git clone https://github.com/Zackriya-Solutions/meeting-minutes
cd meeting-minutes/frontend
pnpm install
./build-gpu.shOnce installed, open the app and it immediately begins listening. Start a meeting in any conferencing tool, and Meetily captures both system audio and microphone simultaneously. When the meeting ends, review the transcript, trigger a summary via your configured LLM (Ollama works out of the box), and export as Markdown.
For build-from-source development, you’ll need Rust, Node.js, and pnpm. Full instructions are in the BUILDING.md docs.
Who Should Use This
✅ Good fit:
- Professionals who discuss sensitive information (legal, healthcare, defense, finance)
- Windows users who want local transcription (nearly every other tool is macOS-only)
- Self-hosting enthusiasts who want full data control
- Cost-conscious teams avoiding $20–30/user/month SaaS fees
- Anyone who wants to try AI meeting notes without creating an account
❌ Not a good fit:
- People who want calendar integration and automatic meeting detection (not available on free tier)
- Teams that need speaker separation beyond basic diarization (enhanced version is PRO)
- Users who need PDF/DOCX exports without paying ($10/month)
- Anyone wanting cloud sync or multi-device access
- Enterprise teams needing SSO/SAML or audit trails
Comparison with Alternatives
| Feature | Meetily (Free) | Meetily PRO | Otter.ai | Fireflies | Granola |
|---|---|---|---|---|---|
| Price | Free | $10/mo | $30/user/mo | $19/user/mo | $20/mo |
| Local processing | ✅ Full | ✅ Full | ❌ Cloud | ❌ Cloud | ✅ Local |
| Windows | ✅ | ✅ | ✅ | ✅ | ❌ |
| macOS | ✅ | ✅ | ✅ | ✅ | ✅ |
| Calendar integration | ❌ | Coming | ✅ | ✅ | ✅ |
| Speaker diarization | Basic | Enhanced | ✅ | ✅ | ✅ |
| Open source | ✅ MIT | ❌ | ❌ | ❌ | ❌ |
| Offline | ✅ | ✅ | ❌ | ❌ | Partially |
| Export formats | Markdown | PDF/DOCX/MD | TXT/SRT/CSV | TXT/CSV/SRT | TXT/PDF |
| Account required | ❌ | ✅ | ✅ | ✅ | ✅ |
The clear differentiator: Meetily is the only player offering native Windows support + full local processing + open source licensing + a genuinely free tier. Otter and Fireflies give you convenience but take your data. Granola is local but macOS-only. Meetily’s combination is currently unique.
Limitations
No calendar integration. Meetily doesn’t pull from your calendar. You start and stop recording manually. On the free tier, there’s no automatic meeting detection — you need to remember to open the app.
Summarization quality on long meetings. The Meetily team documents that summary quality drops on meetings longer than 90 minutes. The free models (especially smaller Ollama models) can lose context in longer transcripts. A GPT-5.4 or Claude Sonnet 4.6 backend improves this significantly, but adds an API cost.
Speaker diarization is basic. The community edition identifies speaker changes but doesn’t consistently label speakers across a meeting. The PRO tier promises enhanced diarization with consistent speaker IDs, but it hasn’t shipped yet (listed as “mid-June” on the README — unclear if it landed).
Database-backed storage, no sync. All data lives in a local SQLite database. If you want to access transcripts from multiple devices, you’ll need to set up your own sync solution. There’s no cloud component, which is a feature for privacy but a limitation for workflow.
Windows-only installer availability. The releases page primarily publishes macOS and Windows binaries. Linux users must build from source, which requires Rust, Node.js, and pnpm — a non-trivial dependency chain.
FAQ
Is Meetily actually private?
Yes — for transcription. Whisper or Parakeet runs entirely on your local hardware. Your audio never leaves your machine. Summarization is also local by default via Ollama. If you connect a cloud LLM API key (Claude, Groq, OpenRouter), the transcript text is sent to that provider for summarization. Audio itself is never uploaded. Storage is a local SQLite database with no sync to any server. No account is required.
Does Meetily work with Zoom, Teams, and Google Meet?
Yes. Meetily captures system audio output and microphone input at the operating system level. It doesn’t integrate with or depend on any specific meeting platform. It works with Zoom, Google Meet, Microsoft Teams, Discord, Slack Huddles, and any other application that produces audio on your computer. No bot joins your call.
What hardware do I need?
Meetily runs on macOS (Apple Silicon recommended, Intel supported), Windows (x64), and Linux (build from source). For real-time transcription, an Apple Silicon Mac or a Windows machine with an NVIDIA GPU is ideal, but it also works on CPU-only machines with slightly higher latency. The Parakeet model is significantly more efficient than Whisper — older hardware handles it well.
What’s the difference between the free and PRO versions?
The free Community Edition is fully open source (MIT) with real-time transcription, AI summaries, Markdown export, and local SQLite storage. PRO ($10/month or $120/year) adds enhanced accuracy transcription models, auto-meeting detection, improved speaker diarization, PDF and DOCX export, custom summarization templates, and priority support. The free edition is not a trial — it’s fully functional and has no expiry.
Can I run Meetily offline?
Yes. With Parakeet or Whisper for transcription and Ollama for local summarization, the entire workflow runs without any internet connection. The only reason Meetily would go online is if you configure it with a cloud LLM API key for summaries.
Does Meetily support languages other than English?
Whisper Large V3 supports 100+ languages with reasonable accuracy. Parakeet-tdt is primarily English-optimized. For non-English meetings, switching to Whisper as the backend model is recommended. Summary generation depends on your LLM’s language capabilities.
How does the system audio capture work technically?
Meetily uses platform-native audio APIs: CoreAudio on macOS (aggregate device with both system output and microphone) and WASAPI loopback on Windows. It creates a virtual audio device that captures both channels simultaneously, with intelligent ducking to reduce system volume during microphone activity. This happens at the OS level, not within any meeting application.
Meetily is a genuine contender in a space dominated by cloud-dependent SaaS products. It’s not as polished as Otter.ai or Fireflies, and it won’t suit everyone — the lack of calendar integration and basic speaker diarization limit its convenience. But for the specific use case of “I need to transcribe meetings without sending my data to a third party,” Meetily is the best open-source option on the market, and its Windows support makes it viable for enterprise adoption in a way that macOS-only competitors simply aren’t.
The fact that it’s MIT-licensed, requires no account, and works offline means it will keep working even if the project changes direction or goes dormant. That’s a level of data sovereignty no SaaS tool can match.
If privacy matters for your meetings, Meetily is worth the download. It costs nothing to try, and the full community edition never expires.