How to Install Meetily: Step-by-Step Guide for macOS, Windows, and Linux

Meetily is a privacy‑first AI meeting assistant built with Tauri 2, Rust, and Next.js that installs via a simple clone-and-build process requiring Node 18+, Rust stable, and pnpm 8+, then launched with the provided clean_run.sh script.

This guide walks you through installing Meetily from source. Because Meetily processes everything locally—including Whisper/Parakeet transcription, Voice Activity Detection (VAD), and audio mixing—no external APIs, Docker containers, or network ports are required. Your meeting data never leaves your device.

Prerequisites for Installing Meetily

Before building Meetily, ensure your system meets these requirements across all three architecture layers:

Core Toolchain

• Node.js 18+ – Runtime for the Next.js frontend
• Rust stable – Compiler for the Tauri native layer
• pnpm 8+ – Package manager (npm install -g pnpm)

Platform-Specific Build Tools

Platform	Required Tools	Install Command
macOS	Xcode Command Line Tools	xcode-select --install
Windows	Visual Studio Build Tools	Install via Visual Studio Installer
Linux	cmake, alsa, pulseaudio	sudo apt install cmake libasound2-dev libpulse-dev

Clone and Install Meetily

The installation process prepares Meetily's three logical layers: the Next.js frontend, the Rust core, and the local audio pipeline.

Step 1: Clone the Repository

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

Step 2: Install Project Dependencies

pnpm install

This installs all Node.js packages for the Next.js UI and prepares the Tauri build environment.

Step 3: Launch Meetily in Development Mode

./clean_run.sh

The clean_run.sh script—located at frontend/clean_run.sh—automates several tasks: cleaning previous builds, installing dependencies, compiling Next.js assets, and launching the Tauri application with info-level logging.

For debug-level logging, use:

./clean_run.sh debug

Understanding Meetily's Architecture

Meetily's local-first design is implemented across three core layers registered in frontend/src-tauri/src/lib.rs:

Frontend Layer (Next.js / TypeScript)

• Handles UI state management
• Communicates with native code via Tauri's invoke API

Rust Core (Tauri Commands)

The main entry point in lib.rs registers all commands and bootstraps the application. This layer manages:

• Audio capture and professional mixing
• Voice Activity Detection (VAD)
• Whisper/Parakeet transcription (no external backend required)
• Local storage and notifications

Audio Pipeline

Implemented in frontend/src-tauri/src/audio/pipeline.rs, this high-performance component features:

• Ring-buffer synchronization of microphone and system audio
• RMS-based ducking and optional RNNoise
• High-pass filtering and EBU R128 loudness normalization
• Direct feeding to VAD and Whisper engines

Platform-Specific Installation Notes

macOS Installation

# Install prerequisites via Homebrew

brew install node rustup
npm install -g pnpm
xcode-select --install

# Then follow standard install steps

pnpm install
./clean_run.sh

Windows Installation

Meetily provides Windows-specific batch scripts:

• clean_run_windows.bat – Development launch
• clean_build_windows.bat – Production build
• dev-gpu.bat – GPU-accelerated development mode

Linux Installation

Ensure audio system dependencies are present:

sudo apt install cmake libasound2-dev libpulse-dev

# Then follow standard install steps

Where Meetily Stores Data

All processing happens locally with models stored in platform-specific application directories:

Platform	Model Storage Path
macOS	~/Library/Application Support/Meetily/
Windows	%APPDATA%\Meetily\
Linux	~/.config/Meetily/

The Whisper engine at frontend/src-tauri/src/whisper_engine/whisper_engine.rs loads models directly from these paths, while frontend/src-tauri/src/summary/templates/loader.rs manages template directories.

Troubleshooting Common Installation Issues

• Rust compilation errors: Ensure rustc --version shows stable (not nightly)
• Audio capture failures: Verify platform audio libraries (alsa/pulseaudio on Linux, CoreAudio on macOS)
• Missing pnpm: Install globally with npm install -g pnpm@8

Summary

• Meetily installs from source using git clone, pnpm install, and ./clean_run.sh
• No external dependencies—transcription models run locally via Rust
• Three-layer architecture: Next.js frontend, Tauri/Rust core, and dedicated audio pipeline
• Key files to know: lib.rs for app setup, pipeline.rs for audio processing, clean_run.sh for launching
• GPU acceleration available via dev-gpu.* scripts on supported platforms

Frequently Asked Questions

Does Meetily require an internet connection or API keys?

No. Meetily is designed for complete privacy. All transcription using Whisper/Parakeet models runs locally through the Rust core. No data is sent to external services, and no API keys are needed for core functionality.

Can I run Meetily without Docker?

Yes. Meetily does not use Docker or any containerization. The Tauri-based architecture compiles to a native desktop application that runs directly on your operating system without virtualization overhead.

What is the difference between clean_run.sh and clean_build_windows.bat?

clean_run.sh (and its Windows equivalent clean_run_windows.bat) launches Meetily in development mode with hot-reload and logging. The clean_build_windows.bat script creates a production-ready executable. GPU-accelerated variants (dev-gpu.sh, dev-gpu.bat) enable hardware-accelerated inference where supported.

How do I update Meetily to the latest version?

Pull the latest changes from the repository and rerun the install process: git pull, pnpm install, then ./clean_run.sh. The application will automatically download updated Whisper models to your local application data directory if needed.

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