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

> Learn to build Meetily from source on Linux macOS and Windows Install development tools compile the llama helper and run Tauri build scripts for GPU accelerated performance.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-07-08

---

**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:

```bash
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:

```bash
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:

```bash
/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:

```powershell
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/dev-gpu.sh) and [`frontend/build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```bash
cd frontend
./dev-gpu.sh

```

This script executes the full build pipeline defined in [`frontend/dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/dev-gpu.sh): it runs [`scripts/auto-detect-gpu.js`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```bash
./build-gpu.sh

```

The [`build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```bash
pnpm install
pnpm tauri:dev

```

For production distribution:

```bash
pnpm tauri:build

```

These commands compile the Rust Tauri core located in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```powershell
pnpm install
pnpm tauri:dev

```

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

```powershell
$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`](https://github.com/Zackriya-Solutions/meetily/blob/main/scripts/auto-detect-gpu.js).

## GPU Acceleration Configuration

Meetily automatically detects available GPU acceleration backends through the [`scripts/auto-detect-gpu.js`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```bash
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/dev-gpu.sh)** and **[`frontend/build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/build-gpu.sh)**: Entry-point scripts that orchestrate the build process, GPU detection, and sidecar compilation
- **[`frontend/scripts/auto-detect-gpu.js`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/BUILDING.md)**: Comprehensive platform-specific build documentation
- **[`docs/GPU_ACCELERATION.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/GPU_ACCELERATION.md)**: Reference for supported GPU backends and manual configuration options
- **[`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./dev-gpu.sh) (Linux) or `pnpm tauri:dev` (macOS/Windows) for development; use [`./build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/pipeline.rs) and transcription logic in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/dev-gpu.sh) and [`build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/build-gpu.sh) scripts pass to Cargo when compiling the Rust components, particularly affecting [`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) 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./build-gpu.sh) to recompile the native components with your changes.