Meeting transcripts are one of the most common use cases for AI — and one of the most privacy-sensitive. Your meetings contain strategic plans, personnel decisions, customer complaints, and intellectual property. Sending audio to cloud-based transcription services (Zoom AI, Otter.ai, Google Meet transcription) means handing that sensitive data to third-party servers.
Meetily eliminates this risk by running 100% locally. Built in Rust with Parakeet and Whisper for speech-to-text, Ollama for summarization, and a privacy-first architecture that never sends your data anywhere, Meetily is the meeting assistant for teams that take confidentiality seriously.
What Is Meetily?
Meetily is a privacy-first AI meeting assistant that provides real-time transcription, speaker diarization (identifying who spoke when), and AI-powered meeting summaries — all processed locally on your machine. No cloud APIs, no data retention, no privacy compromises.
Created by Zackriya Solutions and released under the MIT license, Meetily supports both macOS and Windows. It integrates with your existing meeting platforms (Zoom, Google Meet, Microsoft Teams, Zoom) by capturing audio locally rather than connecting to their APIs.
Key Capabilities
- Real-time transcription — Live captions as people speak, powered by Parakeet (4x faster than Whisper) and Whisper.cpp
- Speaker diarization — Automatically identifies and labels different speakers in the conversation
- Local LLM summarization — Uses Ollama to generate meeting summaries, action items, and key decisions without sending data to the cloud
- 100% local processing — Audio never leaves your machine; all processing happens on-device
- Cross-platform — Native apps for macOS and Windows
- Offline-first — Works without an internet connection (except for optional Ollama model download)
How Meetily Works
Audio Capture
Meetily captures audio from your system's audio output (what other participants say) and/or your microphone (what you say). On macOS, it uses the built-in audio capture APIs. On Windows, it uses the Windows Audio Session API (WASAPI).
┌─────────────────────────────────────────┐
│ Your Meeting (Zoom/Teams/etc.) │
│ │
│ Participant A ──► System Audio ────────┤
│ Participant B ──► System Audio ────────┤
│ You ────────► Microphone ──────────────┤
│ │
│ Meetily Audio Capture Layer │
│ ┌──────────────┐ ┌─────────────────┐ │
│ │ Parakeet/ │ │ Speaker │ │
│ │ Whisper.cpp │ │ Diarization │ │
│ └──────┬───────┘ └────────┬────────┘ │
│ │ │ │
│ ▼ ▼ │
│ Transcript with Speaker Labels │
└─────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Ollama (Local LLM) │
│ ┌──────────────────────────────────┐ │
│ │ Summary │ │
│ │ Action Items │ │
│ │ Key Decisions │ │
│ │ Follow-up Tasks │ │
│ └──────────────────────────────────┘ │
└─────────────────────────────────────────┘
Speech-to-Text Pipeline
Meetily offers two STT engines:
Parakeet (default) — A fast, lightweight speech recognition model by Parrot AI. Meetily uses the Parakeet-1B variant, which is optimized for speed and runs at 4x real-time on modern hardware. This is Meetily's differentiator: fast enough for live transcription without lag.
Whisper.cpp — The C++ port of OpenAI's Whisper model. More accurate than Parakeet for challenging audio (background noise, accents, overlapping speech) but slower. Use this when quality matters more than speed.
Speaker Diarization
Meetily separates speakers using a combination of:
- Voice activity detection (VAD) — Identifies when someone is speaking vs. silent
- Speaker embedding — Uses a lightweight embedding model to cluster audio segments by speaker identity
- Timestamp alignment — Maps each transcribed segment to the correct speaker label
The result is a transcript like:
[Speaker 1] 00:01:23 - Okay, let's start with the Q3 roadmap.
[Speaker 2] 00:01:45 - I think we should prioritize the onboarding flow.
[Speaker 1] 00:02:10 - Agreed. What about the API changes?
[Speaker 3] 00:02:22 - The API changes are blocking the frontend team.
Local Summarization with Ollama
Meetily sends the transcript (not the audio!) to Ollama for summarization. Ollama runs a local LLM — you choose which model:
- Llama 3.1 8B — Fast, good for quick summaries
- Mistral 7B — Balanced speed and quality
- Mixtral 8x7B — Best quality, slower
- Custom models — Any Ollama-compatible model
The summary output includes:
- Executive summary of the meeting
- List of action items with assignees
- Key decisions made
- Open questions / follow-up items
Installation
macOS
# Homebrew
brew install --cask meetily
# Or download the DMG from https://meetily.ai
Windows
Download the MSI installer from https://meetily.ai/downloads
Run the installer and follow the setup wizard
Ollama (for summarization)
Meetily requires Ollama for summarization. Install it first:
# macOS
brew install ollama
ollama pull llama3.1:8b
# Windows
# Download from https://ollama.com
Prerequisites
- macOS 12.0+ or Windows 10+
- Ollama (for summarization; transcription works without it)
- Microphone or system audio capture permissions (granted during first launch)
Usage
Starting a Meeting Capture
- Open Meetily
- Click "Start Recording"
- Select audio source (microphone or system audio)
- Choose STT engine (Parakeet or Whisper.cpp)
- Begin your meeting
Meetily starts transcribing in real-time. The live transcript appears in the main window with speaker labels.
Post-Meeting Summary
After the meeting ends:
- Click "Generate Summary"
- Meetily sends the transcript to Ollama
- Review the generated summary, action items, and decisions
- Export to Markdown, PDF, or copy to clipboard
Export Options
Meetily supports exporting meeting data in multiple formats:
| Format | Contents | Use Case |
|---|---|---|
| Markdown | Full transcript + summary | Notion, Obsidian, GitHub |
| Formatted transcript | Archival, sharing | |
| JSON | Structured data | API integration |
| CSV | Speaker-timestamped segments | Analysis, search |
| Plain Text | Raw transcript | Quick reference |
Keyboard Shortcuts
| Shortcut | Action |
|---|---|
Cmd/Ctrl + R |
Start/Stop recording |
Cmd/Ctrl + S |
Generate summary |
Cmd/Ctrl + E |
Export transcript |
Cmd/Ctrl + Space |
Pause/Resume transcription |
Cmd/Ctrl + Shift + T |
Toggle speaker labels |
Comparison with Alternatives
Meetily vs Otter.ai
| Feature | Meetily | Otter.ai |
|---|---|---|
| Data privacy | 100% local | Cloud-based |
| Cost | Free (open source) | $10.50/month |
| Offline support | Yes | No |
| Speaker diarization | Yes | Yes |
| Summarization | Ollama (local LLM) | OtterIQ (cloud AI) |
| Platform | macOS + Windows | Web + iOS + Android |
| Integration | Manual (audio capture) | Native (Zoom, Teams, GMeet) |
Otter.ai is more polished and has native integrations with meeting platforms. Meetily wins on privacy and cost — your data never leaves your machine, and the software is free.
Meetily vs Fireflies.ai
| Feature | Meetily | Fireflies.ai |
|---|---|---|
| Data privacy | 100% local | Cloud-based |
| Cost | Free | $10-20/month |
| CRM integration | None | HubSpot, Salesforce |
| Meeting platform support | Audio capture only | Native integrations |
| Summarization | Local LLM (configurable) | Cloud AI |
| Open source | Yes (MIT) | No |
Fireflies.ai is a more mature product with deeper integrations. Meetily is the privacy-conscious alternative for teams that cannot afford to send meeting data to third-party servers.
Meetily vs LocalAI + Whisper
| Feature | Meetily | DIY (LocalAI + Whisper) |
|---|---|---|
| Setup complexity | One-click install | Complex (multiple tools) |
| Real-time transcription | Built-in | Requires configuration |
| Speaker diarization | Built-in | Separate tool needed |
| Summarization | Ollama integration | Manual pipeline |
| UI | Polished desktop app | CLI/web interface |
| Maintenance | Updates via app | Self-maintained |
If you want a turnkey solution, Meetily is the answer. If you enjoy tinkering and want maximum customization, building your own pipeline with LocalAI and Whisper gives you more control but requires significant effort.
Performance Benchmarks
Transcription Speed
| Engine | Hardware | Speed | Accuracy |
|---|---|---|---|
| Parakeet-1B | M2 MacBook Air | 4x real-time | 92% (clean audio) |
| Parakeet-1B | M2 MacBook Air | 2.5x real-time | 87% (noisy audio) |
| Whisper.cpp (small) | M2 MacBook Air | 1.5x real-time | 95% (clean audio) |
| Whisper.cpp (medium) | M2 MacBook Air | 0.8x real-time | 97% (clean audio) |
| Whisper.cpp (large) | RTX 4090 | 3x real-time | 98% (any audio) |
Parakeet is fast enough for real-time transcription on any modern machine. Whisper provides higher accuracy at the cost of speed.
Memory Usage
| Component | RAM Usage |
|---|---|
| Meetily (idle) | ~80 MB |
| Meetily + Parakeet (recording) | ~350 MB |
| Meetily + Whisper.cpp (small) | ~600 MB |
| Meetily + Whisper.cpp (large) | ~2.5 GB |
| Ollama (Llama 3.1 8B) | ~5 GB |
Summarization Time
| Model | Time to Summary |
|---|---|
| Llama 3.1 8B | 15-30 seconds (30-min meeting) |
| Mistral 7B | 10-20 seconds |
| Mixtral 8x7B | 45-90 seconds |
| Llama 3.1 70B | 2-5 minutes |
Limitations
No Native Meeting Platform Integration
Meetily captures audio at the system level rather than connecting to Zoom, Teams, or Google Meet APIs. This means:
- It works with any audio source (great for flexibility)
- But it does not get metadata like participant names, meeting titles, or calendar events
- You must manually label speakers in the transcript
Ollama Required for Summarization
Basic transcription works without Ollama. But meeting summaries, action item extraction, and key decision identification all require a local LLM. If you do not want to run Ollama, you get the transcript but not the AI-powered analysis.
Hardware Requirements
Real-time transcription with Whisper.cpp large models requires significant GPU memory (8GB+ VRAM). Parakeet runs comfortably on integrated graphics. Ollama with Llama 3.1 8B needs 8GB+ RAM.
Windows Audio Capture
On Windows, Meetily captures audio via WASAPI, which works for system audio and microphones. However, some virtual audio drivers (like those used by certain meeting platforms) may not expose audio to WASAPI. Test before relying on it for critical meetings.
Editor's Take
Meetily fills a critical gap: privacy-preserving meeting intelligence. The market is dominated by cloud-based solutions (Otter.ai, Fireflies.ai, Zoom AI) that process your meeting data on their servers. For startups, law firms, healthcare organizations, and government agencies, this is a non-starter. Your meetings are not content to be processed by a SaaS company's pipeline.
Meetily's approach — 100% local processing with no data leaving your machine — is the right answer for privacy-conscious teams. The Parakeet engine is impressively fast, making real-time transcription viable on commodity hardware. The Ollama integration for summarization is clever: you get AI-powered analysis without sending your transcript to OpenAI or Anthropic.
The lack of native meeting platform integration is Meetily's biggest weakness. Otter.ai and Fireflies.ai connect directly to Zoom, Teams, and Google Meet, pulling in participant lists, screen shares, and meeting metadata. Meetily only sees audio. This is a deliberate privacy choice (less integration = less data shared), but it means a more manual workflow.
For teams that prioritize privacy over convenience, Meetily is the clear winner. For teams that want a polished, integrated experience and do not mind cloud processing, Otter.ai or Fireflies.ai may be more convenient. But increasingly, organizations are choosing privacy — and Meetily is their best open-source option.
FAQ
Q: Does Meetily work offline?
A: Yes. Transcription (Parakeet or Whisper.cpp) works entirely offline. Summarization via Ollama also works offline once the model is downloaded. Meetily requires no internet connection after initial setup.
Q: Can Meetily transcribe multiple languages?
A: Yes. Both Parakeet and Whisper.cpp support multilingual transcription. Whisper.cpp supports 99+ languages; Parakeet supports 10+ major languages. Speaker diarization works best in single-language meetings.
Q: How accurate is the transcription?
A: Parakeet achieves ~92% word error rate (WER) on clean audio and ~87% on noisy audio. Whisper.cpp small model achieves ~95% on clean audio. For critical meetings, Whisper.cpp provides higher accuracy at the cost of speed.
Q: Can I train Meetily on my team's vocabulary?
A: Not directly. However, Whisper.cpp supports custom language models, and Ollama can use custom fine-tuned models. Advanced users can train domain-specific models and integrate them with Meetily.
Q: Is there a Linux version?
A: Meetily currently supports macOS and Windows. Linux support is planned but not yet available. The core STT engines (Parakeet, Whisper.cpp, Ollama) all run on Linux.
Q: Can I use Meetily for podcasts or interviews?
A: Absolutely. Meetily works for any audio recording — podcasts, interviews, lectures, focus groups. The speaker diarization feature is particularly useful for multi-person recordings.
More from Dibi8
- OmniRoute: Free AI Gateway with 237 Providers
- herdr: Terminal Agent Multiplexer for Coding Agents
- Orca: Parallel Agent Orchestration by StableAI
Sources
Published: July 07, 2026 | Last updated: July 07, 2026 | Stars: 18,692 | License: MIT
Top comments (0)