How to Build Meetily for Production: Cross-Platform Tauri Compilation Guide

To build Meetily for production, install Rust, Node.js, and CMake, then execute the GPU auto-detection scripts (./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 and 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:

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:

./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 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:

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:

brew install cmake node pnpm

Compile the production bundle using Tauri's build command:

pnpm tauri:build

This command processes the Cargo.toml manifest in frontend/src-tauri/Cargo.toml, compiles the Rust entry point at 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:

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:

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: Defines optional GPU acceleration features (cuda, hipblas, vulkan) as Cargo feature flags that conditionally compile backend dependencies.
• 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: 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 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 script on Linux implements the detection logic described in 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.

Summary

• Install Rust, Node.js, pnpm, and CMake before attempting to build Meetily for production.
• Use ./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 and build-gpu.sh?

The dev-gpu.sh script runs ./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 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.

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