How to Build Meetily from Source on Linux, macOS, and Windows

Building Meetily from source requires installing platform-specific development tools (C/C++ compiler, CMake, Node.js with pnpm, and Rust), compiling the optional llama-helper sidecar for local LLM inference, and running the Tauri build scripts that automatically detect and enable GPU acceleration via CUDA, Metal, or Vulkan when available.

Meetily is a privacy-first desktop meeting assistant developed by Zackriya-Solutions that combines a Rust-based Tauri core with a Next.js frontend. The complete source code available in the meetily repository includes automated build scripts for Linux, macOS, and Windows that handle dependency detection, GPU acceleration configuration, and compilation of the transcription engine.

Prerequisites for Building Meetily

Before compiling Meetily from source, install the base toolchain for your operating system. The build process requires a C/C++ compiler, CMake, Git, Node.js, pnpm, and the Rust toolchain.

Linux Prerequisites

Install the system-level build dependencies using your distribution's package manager. For Debian-based systems:

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

For Fedora or Arch Linux, use the equivalent packages (dnf groupinstall "Development Tools" or pacman -S base-devel cmake git).

Install Node.js and pnpm:

curl -fsSL https://get.pnpm.io/install.sh | sh

For GPU acceleration, optionally install CUDA Toolkit (nvidia-cuda-toolkit) or Vulkan SDK (vulkan-sdk libopenblas-dev).

macOS Prerequisites

Install Homebrew, then the required tools:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install cmake node pnpm

macOS builds automatically use Metal for GPU acceleration; no additional SDK installation is required.

Windows Prerequisites

Install Node.js from the official installer, then install Rust:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Install Visual Studio Build Tools with the "Desktop development with C++" workload, and CMake (via installer or choco install cmake).

Building Meetily from Source

The repository provides platform-specific scripts in frontend/dev-gpu.sh and frontend/build-gpu.sh that automate GPU detection and the compilation of the llama-helper sidecar binary.

Linux Build Process

Navigate to the frontend directory and run the development script:

cd frontend
./dev-gpu.sh

This script executes the full build pipeline defined in frontend/dev-gpu.sh: it runs scripts/auto-detect-gpu.js to identify available GPU hardware, compiles the llama-helper Rust binary in debug mode, copies the resulting binary into src-tauri/binaries, and launches the Tauri application with hot-reload enabled.

For a production build that generates a distributable AppImage:

./build-gpu.sh

The build-gpu.sh script performs the same GPU detection but compiles llama-helper in release mode and invokes pnpm run tauri:build to create the final package.

macOS Build Process

Since Metal is universally available on modern macOS systems, GPU detection is automatic. Initialize the project and run the development server:

pnpm install
pnpm tauri:dev

For production distribution:

pnpm tauri:build

These commands compile the Rust Tauri core located in frontend/src-tauri/src/lib.rs, which registers application commands and handles events bridging the Next.js frontend with native code.

Windows Build Process

For CPU-only development builds:

pnpm install
pnpm tauri:dev

To enable GPU acceleration, set the TAURI_GPU_FEATURE environment variable before building:

$env:TAURI_GPU_FEATURE = "cuda"
pnpm tauri:dev

Valid options for TAURI_GPU_FEATURE include cuda, vulkan, metal (macOS only), or none for explicit CPU-only builds. This variable overrides the automatic detection logic implemented in scripts/auto-detect-gpu.js.

GPU Acceleration Configuration

Meetily automatically detects available GPU acceleration backends through the scripts/auto-detect-gpu.js utility. The detection follows this priority order:

1. CUDA: Detected when nvidia-smi is present and nvcc or CUDA_PATH is available
2. Metal: Automatically selected on macOS platforms
3. Vulkan: Requires vulkaninfo and properly set VULKAN_SDK and BLAS_INCLUDE_DIRS environment variables
4. OpenBLAS: Selected when BLAS_INCLUDE_DIRS is set
5. CPU-only: Fallback when no GPU acceleration is detected

The detection results determine which features are passed to the Rust compiler when building llama-helper and the main Tauri application. The transcription engine in frontend/src-tauri/src/whisper_engine/whisper_engine.rs initializes Whisper-rs with the appropriate GPU backend based on these compile-time features.

To manually override automatic detection on any platform:

TAURI_GPU_FEATURE=vulkan ./dev-gpu.sh  # Force Vulkan backend

TAURI_GPU_FEATURE=none ./build-gpu.sh  # Explicit CPU-only build

Key Source Files in the Meetily Repository

Understanding the repository structure helps when debugging build issues or modifying functionality:

• frontend/dev-gpu.sh and frontend/build-gpu.sh: Entry-point scripts that orchestrate the build process, GPU detection, and sidecar compilation
• frontend/scripts/auto-detect-gpu.js: Node.js script that probes system hardware to determine available GPU acceleration capabilities
• frontend/src-tauri/src/lib.rs: Main Tauri application entry point that registers commands and initializes the Rust backend
• frontend/src-tauri/src/audio/pipeline.rs: Core audio engine implementing microphone capture, system audio mixing, voice activity detection (VAD), and buffer management
• frontend/src-tauri/src/whisper_engine/whisper_engine.rs: Rust wrapper around Whisper-rs that handles transcription with GPU acceleration when available
• docs/BUILDING.md: Comprehensive platform-specific build documentation
• docs/GPU_ACCELERATION.md: Reference for supported GPU backends and manual configuration options
• Cargo.toml (root): Workspace manifest defining Rust dependencies and feature flags for different GPU backends

Summary

• Install prerequisites: C++ compiler, CMake, Node.js/pnpm, and Rust toolchain for your platform
• Use automated scripts: Run ./dev-gpu.sh (Linux) or pnpm tauri:dev (macOS/Windows) for development; use ./build-gpu.sh or pnpm tauri:build for production bundles
• GPU acceleration: The build system automatically detects CUDA, Metal, or Vulkan; override with TAURI_GPU_FEATURE environment variable if needed
• Sidecar compilation: The llama-helper binary for local LLM inference builds automatically via the provided scripts and copies to src-tauri/binaries
• Core architecture: The Rust source resides in frontend/src-tauri/src/, with audio processing in pipeline.rs and transcription logic in whisper_engine.rs

Frequently Asked Questions

What are the minimum system requirements to build Meetily from source?

Building Meetily requires a 64-bit operating system (Linux, macOS, or Windows), approximately 4GB of free disk space for the toolchain and dependencies, and a C/C++ compiler. While the application runs on CPU-only systems, GPU acceleration requires compatible NVIDIA (CUDA), AMD/Intel (Vulkan), or Apple Silicon/Intel (Metal) hardware with respective SDKs installed.

How does Meetily automatically detect GPU acceleration during the build process?

The build system executes frontend/scripts/auto-detect-gpu.js which checks for nvidia-smi and CUDA toolkit installations for NVIDIA GPUs, verifies macOS platform for Metal, or searches for Vulkan SDK environment variables. This script outputs the appropriate feature flags that the dev-gpu.sh and build-gpu.sh scripts pass to Cargo when compiling the Rust components, particularly affecting frontend/src-tauri/src/whisper_engine/whisper_engine.rs where the transcription backend initializes.

Can I build Meetily without any GPU support?

Yes. If no GPU is detected or you explicitly set TAURI_GPU_FEATURE=none, Meetily compiles using CPU-only inference via OpenBLAS or pure Rust implementations. The transcription will function identically but with higher CPU utilization and slower processing compared to GPU-accelerated builds. This is the default behavior on Windows when no GPU environment variables are configured.

Where is the Rust source code located, and how do I modify the audio pipeline?

The Rust Tauri source code lives in frontend/src-tauri/src/. The audio recording and mixing logic resides in frontend/src-tauri/src/audio/pipeline.rs, which handles microphone capture, system audio integration, and voice activity detection. After modifying any Rust files, rebuild the application using pnpm tauri:build or ./build-gpu.sh to recompile the native components with your changes.

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