# How to Build Meetily for Production: Cross-Platform Tauri Compilation Guide > Build Meetily for production efficiently. Follow our guide to compile the Rust backend with GPU acceleration and bundle the Next.js frontend for cross-platform installers. - Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily) - Tags: how-to-guide - Published: 2026-07-29 --- **To build Meetily for production, install Rust, Node.js, and CMake, then execute the GPU auto-detection scripts ([`./build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./build-gpu.sh) on Linux or `pnpm tauri:build` on macOS/Windows) to compile the Rust backend with optimal acceleration features and bundle the Next.js frontend into platform-specific installers.** Meetily is a privacy-first, cross-platform desktop AI meeting assistant developed by Zackriya-Solutions. Built with **Tauri**, it combines a **Next.js** frontend running in a webview with a **Rust** backend that manages audio capture, local transcription, and LLM summarization. This guide explains exactly how to build Meetily for production across Linux, macOS, and Windows, referencing the actual source files and build scripts from the repository. ## Prerequisites for Building Meetily Before compiling Meetily for production, you must install the platform-specific toolchains. The build system requires **Rust** (via rustup), **Node.js**, **pnpm**, and **CMake** across all platforms. Linux builds additionally require `build-essential` and optional GPU SDKs (CUDA, ROCm, or Vulkan) for hardware acceleration. Windows requires Visual Studio Build Tools with the C++ workload installed. The repository provides automation scripts in [`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) (located in the project root) that examine your host system for NVIDIA, AMD, or Vulkan drivers. These scripts automatically append the correct Cargo feature flags—`cuda`, `hipblas`, `vulkan`, `openblas`, or none for CPU-only operation—to the compilation command. ## How to Build Meetily for Production on Linux Linux production builds generate an AppImage installer with optional GPU acceleration for the transcription engine. ### Installing Dependencies Install the core build tools and optional GPU SDKs using your distribution's package manager. For Ubuntu or Debian-based systems: ```bash sudo apt update && sudo apt install -y build-essential cmake git ``` For GPU acceleration, install CUDA Toolkit for NVIDIA cards, ROCm for AMD cards, or ensure Mesa Vulkan drivers are present for Vulkan support. ### Running the Production Build Execute the automated build script that detects your GPU and compiles the release binary: ```bash ./build-gpu.sh ``` This script invokes `cargo build --release` with the detected GPU feature flags and then runs `cargo tauri build` to produce the final AppImage. The process compiles the Rust backend including the audio pipeline from [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) and bundles the optimized Next.js assets. You can override the auto-detection by setting the `TAURI_GPU_FEATURE` environment variable before running the script: ```bash TAURI_GPU_FEATURE=cuda ./build-gpu.sh ``` ## How to Build Meetily for Production on macOS macOS builds leverage Metal for GPU acceleration automatically, requiring no additional SDK installation beyond standard development tools. Install the dependencies via Homebrew: ```bash brew install cmake node pnpm ``` Compile the production bundle using Tauri's build command: ```bash pnpm tauri:build ``` This command processes the [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) manifest in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml), compiles the Rust entry point at [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs), and outputs a `.dmg` installer containing the signed application bundle with the Next.js frontend assets embedded. ## How to Build Meetily for Production on Windows Windows production builds require the Visual Studio Build Tools with the C++ workload, available through the Visual Studio Installer. After installing Node.js and Rust via rustup, open PowerShell and navigate to the project root. Compile the production MSI or EXE installer using: ```powershell pnpm tauri:build ``` By default, Windows builds compile for CPU-only operation. To enable GPU acceleration (CUDA or Vulkan), set the feature flag environment variable before building: ```powershell set TAURI_GPU_FEATURE=cuda pnpm tauri:build ``` The build process defined in the Tauri configuration packages the Rust sidecar binary alongside the web assets into a Windows installer suitable for distribution. ## Understanding the Build Architecture The production build process compiles several interconnected components defined in the repository structure: - **[`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml)**: Defines optional GPU acceleration features (`cuda`, `hipblas`, `vulkan`) as Cargo feature flags that conditionally compile backend dependencies. - **[`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs)**: The Rust entry point that registers Tauri commands and initializes the audio pipeline. - **[`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs)**: Contains the audio mixing logic, Voice Activity Detection (VAD), and routing to the Whisper transcription engine. - **Next.js Frontend**: Located in the `frontend` directory, built into static assets and embedded into the Tauri binary during the build process. The [`docs/BUILDING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/BUILDING.md) file provides the canonical reference for platform-specific edge cases and troubleshooting steps. ## GPU Acceleration Configuration Meetily's transcription engine supports multiple GPU backends to accelerate local Whisper model inference. The [`build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/build-gpu.sh) script on Linux implements the detection logic described in [`docs/BUILDING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/BUILDING.md), checking for available drivers in the order: CUDA, HIPBlas (ROCm), Vulkan, then falling back to OpenBLAS or CPU-only. You can force a specific backend by exporting `TAURI_GPU_FEATURE` before invoking the build: - **CUDA**: `export TAURI_GPU_FEATURE=cuda` - **AMD ROCm**: `export TAURI_GPU_FEATURE=hipblas` - **Vulkan**: `export TAURI_GPU_FEATURE=vulkan` - **CPU-only**: `export TAURI_GPU_FEATURE=` This environment variable propagates to the `cargo build` command, ensuring the compiled binary links against the correct GPU libraries specified in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). ## Summary - Install Rust, Node.js, pnpm, and CMake before attempting to build Meetily for production. - Use [`./build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./build-gpu.sh) on Linux to auto-detect GPU capabilities and produce an AppImage with optimal acceleration. - Run `pnpm tauri:build` on macOS and Windows to generate native installers (DMG or MSI/EXE). - Override GPU detection by setting the `TAURI_GPU_FEATURE` environment variable when compiling. - The build process compiles the Rust backend from `frontend/src-tauri/src/` and bundles the Next.js frontend into a standalone desktop application. ## Frequently Asked Questions ### Does Meetily require an internet connection to build? No. Meetily builds entirely offline once dependencies are cached. The build process compiles local Whisper and LLM models into the binary, though initial `pnpm install` and `cargo build` commands require network access to download crates and npm packages. ### Can I build Meetily without GPU support? Yes. The build scripts automatically fall back to CPU-only compilation if no GPU SDK is detected. You can also force CPU-only mode by unsetting `TAURI_GPU_FEATURE` or passing no arguments to the standard `cargo tauri build` command without the helper scripts. ### What is the difference between [`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)? The [`dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/dev-gpu.sh) script runs [`./dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./dev-gpu.sh), which detects your GPU and executes `pnpm tauri:dev` to start a development server with hot-reload enabled. The [`build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/build-gpu.sh) script performs the same detection but invokes `cargo build --release` followed by `cargo tauri build` to create the production installer without development debugging symbols. ### Where are the compiled binaries located after building? On Linux, the AppImage appears in `frontend/src-tauri/target/release/bundle/appimage/`. On macOS, the DMG is located in `frontend/src-tauri/target/release/bundle/dmg/`. On Windows, the MSI and EXE installers are found in `frontend/src-tauri/target/release/bundle/msi/` and `bundles/nsis/` respectively.