Prerequisites for Running Meetily: Complete Setup Guide for macOS, Windows, and Linux

To run Meetily, you need either a pre-built binary (macOS Apple Silicon or Windows x64) or a development toolchain including Rust, Node.js (≥18), pnpm, CMake, and a C/C++ compiler to build from source on any platform.

Meetily is a privacy-first AI meeting assistant built with Tauri and Next.js that runs entirely on your local machine. Understanding the prerequisites for running Meetily ensures smooth installation whether you choose a pre-built release or compile from source. This guide covers platform-specific requirements, audio dependencies, and optional GPU acceleration based on the official source code in the Zackriya-Solutions/meetily repository.

Platform Support and Binary Availability

Meetily distributes pre-built binaries for specific platforms while requiring source compilation for others.

macOS (Apple Silicon)

Pre-built binaries are available for Apple Silicon Macs as .dmg files (e.g., meetily_0.4.0_aarch64.dmg). Drag-and-drop installation requires no additional dependencies. Building from source requires the standard development toolchain plus Xcode command-line tools for the C/C++ compiler.

Windows (x64)

Windows users can download x64-setup.exe installers for immediate use. To build from source, you need Visual Studio Build Tools with the C++ workload installed alongside Rust and Node.js.

Linux

No official binary distribution exists for Linux. You must compile from source using Rust, Node.js, pnpm, CMake, and your distribution's C/C++ toolchain (gcc or clang). GPU acceleration via CUDA or ROCm is optional but recommended for faster transcription.

Core Development Toolchain

Building Meetily from source requires these specific tools as implemented in the repository's build configuration:

• Rust (stable): Powers the Tauri backend in frontend/src-tauri/src/lib.rs, audio pipeline processing, and Whisper transcription
• Node.js (≥18): Drives the Next.js UI and Tauri asset pipeline
• pnpm: Package manager for JavaScript dependencies
• CMake: Required for compiling native audio libraries including whisper-rs and FFmpeg bindings
• C/C++ toolchain: Platform-specific compiler for native crates (build-essential on Ubuntu, Xcode tools on macOS, Visual Studio Build Tools on Windows)

Audio Capture Dependencies

Meetily captures both microphone and system audio using platform-specific APIs implemented in frontend/src-tauri/src/audio_v2/ and frontend/src-tauri/src/audio/pipeline.rs.

macOS Audio Requirements

• Microphone: System permission required
• System Audio: Captured via ScreenCaptureKit requiring screen-recording permission
• Implementation: Audio mixing and VAD processing handled by Rust modules in src-tauri/src/audio_v2/

Windows Audio Requirements

• Microphone: WASAPI input
• System Audio: WASAPI loopback capture
• Permissions: No extra OS-level permissions beyond standard audio access

Linux Audio Requirements

• Microphone: ALSA or PulseAudio
• System Audio: PulseAudio monitor or ALSA "default" device
• Permissions: User must belong to the audio group

Optional GPU Acceleration

Hardware-accelerated transcription is available but optional. The build system detects GPU capabilities through scripts referenced in docs/BUILDING.md.

• NVIDIA: CUDA Toolkit for GPU-accelerated Whisper inference
• AMD: ROCm support on compatible Linux distributions
• Cross-platform: Vulkan compute shaders for generic GPU acceleration

Set TAURI_GPU_FEATURE=cuda environment variable before running ./build-gpu.sh to force CUDA compilation.

Step-by-Step Installation Examples

Installing Pre-Built Binary on macOS

# Download the latest .dmg from GitHub Releases

open https://github.com/Zackriya-Solutions/meetily/releases/latest

# Mount the DMG and drag Meetily to /Applications

# Launch from Applications folder (grant microphone and screen recording permissions when prompted)

Building from Source on Linux (CPU-Only)

# Install system dependencies

sudo apt update && sudo apt install -y build-essential cmake git

# Install Rust

curl https://sh.rustup.rs -sSf | sh

# Install Node.js 18+ and pnpm

curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt install -y nodejs
npm i -g pnpm

# Clone and build

git clone https://github.com/Zackriya-Solutions/meetily
cd meetily
pnpm install

# Development mode with auto-detection

./dev-gpu.sh

# Run the application

pnpm tauri:dev

Enabling CUDA Acceleration on Linux

# Install NVIDIA drivers and CUDA toolkit

sudo apt install nvidia-driver-550 nvidia-cuda-toolkit

# Verify installation

nvidia-smi
nvcc --version

# Build with CUDA support

TAURI_GPU_FEATURE=cuda ./build-gpu.sh

Starting a Recording via API

Once running, Meetily exposes Tauri commands defined in frontend/src-tauri/src/audio/recording_commands.rs:

import { invoke } from '@tauri-apps/api/tauri';

await invoke('start_recording', {
  mic_device_name: 'Built-in Microphone',
  system_device_name: 'BlackHole 2ch',
  meeting_name: 'Team Stand-up'
});

This invokes the recording orchestration logic in recording_manager.rs and audio pipeline in pipeline.rs.

Generating Summaries with Local LLMs

Meetily integrates with Ollama, Claude, Groq, OpenRouter, and OpenAI through frontend/src-tauri/src/summary/service.rs:

import { invoke } from '@tauri-apps/api/tauri';

const summary = await invoke('generate_summary', {
  provider: 'ollama',
  model: 'llama2',
  transcript_id: 42
});

No additional runtime prerequisites are required for LLM integration beyond HTTP connectivity to your chosen endpoint.

Summary

• Binary installation requires only macOS Apple Silicon or Windows x64 hardware with standard audio permissions
• Source builds mandate Rust, Node.js ≥18, pnpm, CMake, and platform-specific C/C++ compilers as documented in docs/BUILDING.md
• Audio capture depends on ScreenCaptureKit (macOS), WASAPI (Windows), or PulseAudio/ALSA (Linux) with appropriate user permissions
• GPU acceleration is optional and configurable via TAURI_GPU_FEATURE environment variables during the build process
• LLM integration requires no external API keys unless connecting to cloud providers rather than local Ollama instances

Frequently Asked Questions

Do I need an NVIDIA GPU to run Meetily?

No. Meetily runs entirely on CPU using the Whisper engine implemented in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. NVIDIA GPUs with CUDA support optional hardware acceleration for faster transcription, but the application functions without them.

Can I run Meetily on Intel-based Macs?

The current pre-built binaries target Apple Silicon (aarch64) only. Intel Mac users must build from source using the standard Rust/Node.js toolchain, though Metal GPU acceleration benefits may be limited compared to Apple Silicon.

What permissions does Meetily require on macOS?

macOS requires two specific permissions: microphone access for capturing your voice and screen recording permission for capturing system audio via ScreenCaptureKit. These are requested at first launch and can be managed in System Preferences under Security & Privacy.

Is an internet connection required to use Meetily?

No. Meetily operates as a fully local application. All transcription happens via the local Whisper engine in whisper_engine.rs, and you can use local LLMs via Ollama for summaries. Internet is only required if you choose to use cloud-based LLM providers like Claude or OpenAI.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}