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

> Discover the prerequisites for running Meetily on macOS, Windows, and Linux. Learn whether you need pre-built binaries or a specific development toolchain for setup.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: getting-started
- Published: 2026-08-03

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./build-gpu.sh) to force CUDA compilation.

## Step-by-Step Installation Examples

### Installing Pre-Built Binary on macOS

```bash

# 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)

```bash

# 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

```bash

# 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs):

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/recording_manager.rs) and audio pipeline in [`pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/pipeline.rs).

### Generating Summaries with Local LLMs

Meetily integrates with Ollama, Claude, Groq, OpenRouter, and OpenAI through [`frontend/src-tauri/src/summary/service.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/service.rs):

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.