Meetily - Self-Hosted AI Meeting Notes

TL;DR

TL;DR: Meetily is an open-source desktop AI meeting assistant for macOS and Windows that transcribes meetings live with local Whisper or Parakeet models and summarizes them with a local LLM — no audio, transcript, or meeting content ever leaves your machine.

Security Notice: Use the Official Repository

If you are reading this to install Meetily, read this section first.

There was an unauthorized GitHub repository at github.com/meetily/meetily that impersonated the Meetily project and distributed malware under its name. GitHub has since taken that repository down, but links to it still circulate in search results, forum posts, and AI-generated install guides.

The one and only official repository is:

https://github.com/Zackriya-Solutions/meetily

A few practical notes so you do not get lost:

• The project was originally published as Zackriya-Solutions/meeting-minutes. GitHub redirects that older path to the current meetily repository, so both URLs resolve to the same official code. Anything outside the Zackriya-Solutions organisation is not the real project.
• Official installers are published on the GitHub Releases page and mirrored at meetily.ai/downloads.
• Meetily is not distributed as a Docker image, and there is no container registry to pull from. If a guide tells you to run docker-compose up, it is describing a different product.

What Is Meetily?

Meetily is a privacy-first AI meeting assistant that runs entirely on your own desktop machine. It captures your meeting audio, transcribes it in real time with a local speech-recognition model, and generates a summary with an LLM you control — without sending meeting content to a third-party cloud service.

The project describes itself like this:

A privacy-first AI meeting assistant that captures, transcribes, and summarizes meetings entirely on your infrastructure. Built by expert AI engineers passionate about data sovereignty and open source solutions.

Under the hood it is a single self-contained Tauri application: a Rust backend (src-tauri) doing the audio and inference work, with a Next.js frontend for the interface. It is MIT licensed and free to use.

Key characteristics:

• Local processing — transcription and storage happen on your machine, not a server you rent
• No bot joins the call — Meetily records locally instead of asking to be invited to your Zoom or Meet
• Live transcription — the transcript builds while the meeting is happening, not afterwards
• Bot-free capture — microphone and system audio are mixed together with ducking and clipping prevention
• Import existing audio — the “Import & Enhance” feature (beta) turns recorded files into transcripts, and can re-transcribe with a different model or language
• Provider choice for summaries — Ollama (fully local) is recommended, with Claude, Groq, OpenRouter, and any custom OpenAI-compatible endpoint also supported

Platform Support

Platform	How you get it	Notes
macOS	Signed .dmg installer (Apple Silicon)	Metal and CoreML acceleration enabled automatically
Windows	x64-setup.exe or .msi installer	Packaged Whisper build uses Vulkan; requires an AVX2-capable x64 CPU
Linux	Build from source	No official binary installer is published

For Linux and for any GPU acceleration beyond the default, you build from source. The Windows installer ships a Vulkan-enabled Whisper build and does not select CUDA automatically — CUDA requires a source build with a compatible NVIDIA CUDA toolchain.

Prerequisites

For the installers:

• macOS: an Apple Silicon Mac. The published release asset is meetily_0.4.1_aarch64.dmg.
• Windows: a 64-bit x64 CPU with AVX2 support. AVX-512 is not required. Windows 10 or later.

For a source build:

• Node.js 18 or later
• Rust (latest stable)
• pnpm 9.15.9
• Platform build tooling: Xcode Command Line Tools on macOS, Visual Studio Build Tools with C++ support on Windows, and build-essential cmake git on Linux

Step 1: Install the Desktop App

This is the recommended path for macOS and Windows.

macOS

1. Open the latest release page.
2. Download meetily_0.4.1_aarch64.dmg.
3. Open the downloaded .dmg file.
4. Drag Meetily into your Applications folder.
5. Launch Meetily from Applications.

Windows

1. Open the latest release page.
2. Download meetily_0.4.1_x64-setup.exe (an .msi installer is published alongside it).
3. Run the installer and follow the prompts.

You can also grab the same installers from meetily.ai/downloads.

Step 2: Build from Source (Linux, or for custom acceleration)

Clone the official repository and build the frontend:

npm install -g [email protected]
git clone https://github.com/Zackriya-Solutions/meetily.git
cd meetily/frontend
pnpm install --frozen-lockfile
./build-gpu.sh

The frozen install keeps the committed pnpm-lock.yaml and the installed dependency set aligned, which is what the project requires for reproducible builds.

For development mode with hot reload, use the development script instead:

./dev-gpu.sh

What the build script does automatically

build-gpu.sh and dev-gpu.sh detect your hardware and configure acceleration. From the project’s Linux build guide, the detection priority is:

Priority	Hardware	What it checks	Result
1	NVIDIA CUDA	nvidia-smi present plus CUDA_PATH or nvcc	--features cuda
2	AMD ROCm	rocm-smi present plus ROCM_PATH or hipcc	--features hipblas
3	Vulkan	vulkaninfo present plus VULKAN_SDK and BLAS_INCLUDE_DIRS	--features vulkan
4	OpenBLAS	BLAS_INCLUDE_DIRS set	--features openblas
5	CPU-only	none of the above	no features, pure CPU

A CPU-only build still works — the scripts fall back to optimised CPU mode.

One practical gotcha: having GPU drivers is not enough. The detection needs the development SDK — the CUDA toolkit, ROCm, or the Vulkan SDK — to enable acceleration.

Step 3: Choose a Transcription Model

Meetily downloads the speech model on the device, so you pick the model once and it runs locally from then on. The app ships two local engines.

Whisper

The Whisper model list is defined in the app’s own model catalogue, with the sizes and ratings shown in the interface:

Model	Download size	Accuracy	Speed
large-v3	2951 MB	High	Slow
large-v3-turbo	1549 MB	High	Medium
medium	1463 MB	High	Slow
small	466 MB	Good	Medium
base	142 MB	Good	Fast
tiny	39 MB	Decent	Very Fast

The app’s own guidance: large-v3 is for the highest accuracy on important meetings, small is fast with good quality for quick transcription, and tiny is the fastest for real-time use.

Parakeet

Meetily also supports NVIDIA’s Parakeet model, which the project describes as delivering roughly 4x faster live transcription than Whisper. The in-app names are:

Model	In-app name	Profile
parakeet-tdt-0.6b-v3-int8	Lightning	Real time, best for speed, great accuracy (recommended)
parakeet-tdt-0.6b-v2-int8	Compact	Real time, smaller size
parakeet-tdt-0.6b-v3-fp32	Precise	20x real-time, higher accuracy

Step 4: Choose a Summary Provider

Once transcription is running, Meetily needs a language model for the summary. The app supports several providers, and you pick one in Settings:

• Ollama — runs locally on your machine and is the recommended option if you want summaries to stay fully offline
• Claude, Groq, OpenRouter, and OpenAI
• A custom OpenAI-compatible endpoint — for organisations with their own AI infrastructure

The community edition stays free and open source either way; the choice of provider is a per-user setting in the app, not an environment file you edit before launch.

Step 5: Record Your First Meeting

1. Launch Meetily and pick your transcription model and summary provider in Settings.
2. Select the microphone and, if you want the other side of the call, the system audio device. The app mixes both simultaneously with intelligent ducking and clipping prevention.
3. Start recording. The live transcript appears as the meeting runs.
4. Stop the recording when the meeting ends and review the transcript and generated summary in the built-in editor.
5. To work with audio you already have, use the Import & Enhance feature (beta): import the file to generate a transcript, and re-transcribe it with a different model or language if you are not happy with the first result.

Limitations

• Desktop only, no server mode — Meetily is a desktop application. There is no multi-user web app, no web UI on a port, and no shared team instance in the community edition.
• Speaker identification is a Meetily Pro feature — automatic diarization that works out who said what is not part of the free community edition. In the community build, the speaker field on a transcript records which audio source a line came from (microphone or system audio), not the identity of the person.
• No official Linux installer — Linux users must build from source, which means a Rust and Node.js toolchain on the machine.
• Windows CPU requirement — the packaged installer needs an AVX2-capable x64 CPU, and CUDA acceleration is not selected by the standard installer.
• Accuracy depends on audio — transcription quality drops with background noise, overlapping speakers, and poor microphone placement, regardless of the model you pick.
• Meetily Pro is a separate product — PRO is a distinct professional solution with its own codebase, offering enhanced accuracy, custom summary templates, PDF/DOCX/Markdown exports, auto-meeting detection, and self-hosted deployment options for teams. The community edition remains free and open source.

Competitive Landscape

• Otter.ai — cloud service with real-time collaboration, but meeting audio and transcripts live on someone else’s servers
• Fireflies.ai — similar cloud model, with CRM integrations
• Whisper plus your own scripts — DIY, and you maintain the whole pipeline yourself
• Meetily — a packaged desktop app with local transcription and local summarization, no assembly required

For teams that have ruled out cloud transcription on legal or compliance grounds, Meetily is one of the few options that keeps the meeting audio on a machine you control.

Evaluation Checklist

• App installs cleanly on macOS (.dmg drag-to-Applications) or Windows (.exe / .msi)
• A transcription model downloads and shows as Available in the model manager
• Live transcript appears while a meeting is recording, not only after it stops
• Microphone and system audio are both captured and mixed without clipping
• Ollama produces a summary while the machine is offline
• A pre-existing audio file imports and produces a transcript via Import & Enhance
• Re-transcribing the same file with a different model works
• No outbound network traffic during transcription and summarisation (verify with tcpdump or your firewall logs)
• Transcripts and recordings persist across app restarts
• You know which parts of the feature set require Meetily Pro

Security and Privacy Notes

Local by default. The whole point of the architecture is that meeting content stays on the machine. Transcription runs against a local Whisper or Parakeet model, and with Ollama selected as the summary provider, no meeting audio or transcript is transmitted anywhere.

Check the summary provider before you start. This is the one place where data can leave the device. If you configure Claude, Groq, OpenRouter, or an OpenAI-compatible endpoint, your transcript and summary prompts are sent to that service. If the requirement is that nothing leaves the machine, use Ollama and confirm the app is not making outbound connections.

Supply chain. Model files are downloaded by the app and stored locally. Because the project was the target of an impersonation attempt, verify that the repository you clone is the Zackriya-Solutions organisation and that release assets come from its official Releases page.

Multi-user access. The community edition is a single-user desktop application. It is not designed to be exposed to a network, so there is no web UI to put behind a reverse proxy — and equally no web UI that needs one.

FAQ

Q: Is Meetily a Docker or self-hosted server app? A: No. Meetily is a desktop application for macOS and Windows, and it can be built from source on Linux. There is no Docker image and no web interface — it runs entirely as an app on your own machine, which is what makes the local-processing guarantee meaningful.

Q: Which repository is the official one? A: https://github.com/Zackriya-Solutions/meetily. A lookalike repository at github.com/meetily/meetily was an impersonation that distributed malware and has been taken down by GitHub. The project was formerly named meeting-minutes, and GitHub redirects that old path to the current repository.

Q: Does Meetily join my meeting as a bot? A: No. It captures audio locally from your microphone and, optionally, your system audio, so nothing is invited into the call and no participant sees a bot join.

Q: Can Meetily transcribe meetings in languages other than English? A: The Whisper models are multilingual, so non-English meetings are supported. The “Import & Enhance” feature also lets you re-transcribe an existing recording with a different model or language. Accuracy varies by language, accent, and audio quality.

Q: Can I use it with Zoom, Teams, or Google Meet recordings? A: Yes, through the Import & Enhance feature — import the audio file and Meetily generates the transcript locally. For live meetings you can also capture the system audio directly during the call.

Q: Does it work fully offline? A: With Ollama configured as the summary provider, yes. Both transcription engines run locally, so once the model is downloaded the app needs no network connection. If you pick a cloud provider for summaries, the transcript is sent to that provider.

Q: How is this different from Meetily Pro? A: The community edition is free, MIT licensed, and open source, and includes local transcription, AI summaries, and the core features. Meetily Pro is a separate professional product with a different codebase, adding enhanced accuracy, custom summary templates, PDF/DOCX/Markdown exports, auto-meeting detection, speaker identification, and self-hosted deployment options for teams of 2 to 100.

Q: Can multiple team members share one Meetily instance? A: Not in the community edition — it is a single-user desktop application. Team deployment is a Meetily Pro feature.

Q: Where do I get the installers? A: From the official GitHub Releases page or from meetily.ai/downloads. The current release at the time of writing is v0.4.1, which publishes a .dmg for macOS and .exe and .msi installers for Windows.

Conclusion

Meetily is a polished desktop application rather than a self-hosted service, and that distinction matters for how you evaluate it. If your requirement is “meeting intelligence with a hard privacy boundary”, it delivers that: local Whisper or Parakeet transcription during the meeting, a summary from a local Ollama model, and storage that never leaves the laptop.

The trade-offs are equally concrete. There is no server to share with a team, no Linux binary to download, and automatic speaker identification sits behind Meetily Pro rather than in the open-source build.

For an individual or a small team that has ruled out cloud transcription on compliance grounds and wants meeting notes without handing a vendor the audio, the free community edition is a genuinely capable option — and the official repository is the only place to get it.

Source and Accuracy Notes

• Project page: meetily.ai
• Official installers: meetily.ai/downloads
• Source repository: github.com/Zackriya-Solutions/meetily
• Releases: github.com/Zackriya-Solutions/meetily/releases/latest — latest release v0.4.1, published 2026-09-12
• License: MIT (verified via GitHub API license.spdx_id)
• HN launch thread: news.ycombinator.com/item?id=45810161
• Install commands, model tables, and GPU detection order are quoted from the project’s own README.md, docs/BUILDING.md, docs/building_in_linux.md, frontend/README.md, frontend/src/lib/whisper.ts, and frontend/src/lib/parakeet.ts
• Repository metadata (31,936 stars, 3641 forks, MIT, main branch) read from the GitHub REST API on 2026-10-19