How to Build Meetily with GPU Acceleration: CUDA, Vulkan, and Metal Support

Build Meetily with GPU acceleration by enabling the corresponding Cargo feature (cuda, vulkan, metal, or coreml) during compilation, either manually with cargo build --release --features cuda or via the provided build-gpu.sh helper script.

Meetily is an open-source meeting transcription application that leverages the whisper-rs crate for audio processing. While the default build runs on CPU, you can compile Meetily with GPU acceleration to dramatically speed up transcription using NVIDIA CUDA, AMD/Intel Vulkan, or Apple Metal. This guide explains how to configure the build system to target your specific hardware backend as implemented in the Zackriya-Solutions/meetily repository.

How GPU Acceleration Works in Meetily

Meetily's transcription engine relies on whisper-rs, which supports multiple GPU backends selected at compile-time. The backend is not a runtime choice—it is baked into the binary through Cargo features defined in frontend/src-tauri/Cargo.toml.

Available GPU Backends

The crate declares optional features (lines 38-49) that map directly to whisper-rs backends:

• cuda → whisper-rs/cuda (NVIDIA GPUs on Linux/Windows)
• vulkan → whisper-rs/vulkan (AMD/Intel GPUs)
• metal → whisper-rs/metal (macOS Apple Silicon)
• coreml → whisper-rs/coreml (macOS Core ML)
• hipblas → whisper-rs/hipblas (AMD ROCm on Linux)

By default, the platform-default feature is enabled, which selects Metal on macOS and OpenBLAS (CPU) on Windows/Linux.

Building with the Helper Script

The repository includes frontend/build-gpu.sh, a convenience script that automates GPU detection and feature selection.

Automatic GPU Detection

The script runs frontend/scripts/auto-detect-gpu.js to probe your system and sets the TAURI_GPU_FEATURE environment variable. It then builds the Rust sidecar with the detected feature:

./frontend/build-gpu.sh

Script Implementation Details

The script constructs the appropriate Cargo flags based on the detected GPU (lines 68-84 of build-gpu.sh):

HELPER_FEATURES=""
if [ -n "$TAURI_GPU_FEATURE" ]; then
    LLAMA_FEATURE="$TAURI_GPU_FEATURE"
    if [ "$LLAMA_FEATURE" = "coreml" ]; then
        LLAMA_FEATURE="metal"
    fi
    HELPER_FEATURES="--features $LLAMA_FEATURE"
fi
(cd "$HELPER_DIR" && cargo build --release $HELPER_FEATURES)

On Linux, the script also exports CUDA-specific CMake variables (lines 17-22) to support downstream native builds.

Manual Build Process

If you prefer explicit control over the build flags, invoke Cargo directly after setting the feature flag.

Step 1: Select GPU Feature

Set the TAURI_GPU_FEATURE environment variable or pass the feature directly to Cargo:

# For NVIDIA GPUs

export TAURI_GPU_FEATURE=cuda
cargo build --release --features cuda

# For AMD/Intel GPUs

export TAURI_GPU_FEATURE=vulkan
cargo build --release --features vulkan

Step 2: Build the Tauri Application

After compiling the Rust library with GPU support, build the full application:

pnpm run tauri:build

# or

npm run tauri:build

Platform-Specific Considerations

Different operating systems have specific requirements for GPU acceleration in Meetily.

macOS (Apple Silicon)

Metal and CoreML support are available. While platform-default auto-selects Metal on macOS, you can force it explicitly:

cargo build --release --features metal

Windows

The default Windows build is CPU-only. You must explicitly enable GPU features:

# NVIDIA

cargo build --release --features cuda

# AMD/Intel

cargo build --release --features vulkan

Linux

Linux supports CUDA for NVIDIA and Vulkan for AMD/Intel. Additionally, AMD ROCm users can use the hipblas feature:

cargo build --release --features hipblas

Verifying GPU Acceleration

After building, verify the GPU backend is active by checking the runtime logs. The whisper engine initialization in frontend/src-tauri/src/whisper_engine/whisper_engine.rs loads the Whisper model using the compiled GPU backend and will indicate which provider is active.

Summary

• Compile-time selection: GPU backends in Meetily are selected via Cargo features (cuda, vulkan, metal, coreml, hipblas) defined in frontend/src-tauri/Cargo.toml, not at runtime.
• Helper script: Use ./frontend/build-gpu.sh to auto-detect your GPU and build with the correct feature flag.
• Manual builds: Run cargo build --release --features <backend> followed by pnpm run tauri:build to create a GPU-accelerated binary.
• Platform defaults: macOS defaults to Metal, while Windows and Linux default to CPU (OpenBLAS) unless overridden.

Frequently Asked Questions

What GPU backends does Meetily support?

Meetily supports NVIDIA CUDA, AMD/Intel Vulkan, Apple Metal, Apple CoreML, and AMD ROCm (via HIP-BLAS). These are enabled through the respective Cargo features in frontend/src-tauri/Cargo.toml (lines 38-49).

Can I switch GPU backends without rebuilding Meetily?

No. The GPU backend is selected at compile-time through Cargo features. To switch from CUDA to Vulkan, you must rebuild the application with cargo build --release --features vulkan and then rebuild the Tauri frontend.

Does the helper script work on all platforms?

Yes, frontend/build-gpu.sh works on macOS, Windows (via Git Bash or WSL), and Linux. It auto-detects available GPUs using scripts/auto-detect-gpu.js and sets the appropriate TAURI_GPU_FEATURE environment variable before invoking Cargo.

Why is my GPU not being detected on Linux?

Ensure you have the appropriate drivers installed (NVIDIA drivers for CUDA, Mesa for Vulkan). The auto-detection script probes for available libraries, but you can bypass detection by manually exporting the feature: export TAURI_GPU_FEATURE=cuda before running the build commands.

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