How to Build GPU-Specific Meetily Tauri Binaries for Metal, CUDA, or Vulkan Backends

Build GPU-specific Meetily Tauri binaries by setting the TAURI_GPU_FEATURE environment variable to metal, cuda, or vulkan before running the provided wrapper scripts.

Meetily is an open-source meeting assistant built as a Tauri application that bundles a Rust core with a Next.js frontend. To achieve real-time transcription performance, the Rust backend must compile with GPU-accelerated Whisper-rs backends. This guide covers how to build Meetily Tauri binaries targeting specific GPU architectures across macOS, Linux, and Windows.

Understanding the GPU Acceleration Architecture

Meetily's transcription pipeline relies on whisper-rs, a Rust wrapper for OpenAI's Whisper model that supports multiple GPU compute backends. The architecture separates GPU detection from the UI layer, allowing the Rust core to leverage hardware acceleration while the frontend remains platform-agnostic.

The whisper-rs Integration

In frontend/src-tauri/Cargo.toml, optional Cargo features map directly to whisper-rs GPU backends:

• cuda — Links against NVIDIA cuBLAS for CUDA-enabled GPUs
• metal — Uses Apple CoreML on macOS Apple Silicon/Intel
• vulkan — Cross-platform compute shader backend for AMD/Intel/NVIDIA
• openblas — CPU fallback using optimized BLAS libraries

When active, these features compile the Rust transcription worker with the appropriate GPU libraries. The Tauri command layer in the Rust source remains unchanged, communicating results to the UI via standard Tauri events regardless of the backend used.

Auto-Detection vs Manual Configuration

The repository includes frontend/scripts/auto-detect-gpu.js, a Node.js script invoked by dev-gpu.sh and build-gpu.sh. This script inspects the system for:

• nvidia-smi (NVIDIA GPUs)
• rocm-smi (AMD ROCm)
• vulkaninfo (Vulkan-capable hardware)
• Environment variables: CUDA_PATH, VULKAN_SDK, ROCM_PATH

Based on detection, the script exports TAURI_GPU_FEATURE to trigger the corresponding Cargo feature during compilation.

Building GPU-Specific Binaries by Platform

macOS with Metal

Metal support requires no additional SDK installation on modern macOS systems—it leverages the built-in CoreML framework.

Run the automatic build script which defaults to Metal on Apple Silicon:

./frontend/build-gpu.sh

To explicitly enforce Metal compilation (bypassing any detection logic):

TAURI_GPU_FEATURE=metal ./frontend/build-gpu.sh

Verify Metal is active in the build output by checking that whisper-rs compiled with the metal feature in frontend/src-tauri/Cargo.toml.

Linux with CUDA or Vulkan

Linux builds auto-detect in the priority order: CUDA → Vulkan → OpenBLAS. Ensure you have installed the development toolkit, not just drivers.

For automatic detection (recommended):

# Install build dependencies (Ubuntu/Debian example)

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

# Run the GPU-enabled development script

./frontend/dev-gpu.sh   # Hot-reload mode

# Or for production:

./frontend/build-gpu.sh

To force CUDA compilation on NVIDIA hardware:

# Verify CUDA Toolkit installation

export CUDA_PATH=/usr/local/cuda
export PATH=$CUDA_PATH/bin:$PATH

# Override auto-detection

TAURI_GPU_FEATURE=cuda ./frontend/build-gpu.sh

For AMD or Intel GPUs supporting Vulkan:

# Ensure Vulkan SDK is installed and VULKAN_SDK is set

export VULKAN_SDK=/path/to/vulkan-sdk

TAURI_GPU_FEATURE=vulkan ./frontend/build-gpu.sh

Windows with CUDA or Vulkan

Windows requires manual SDK installation and environment configuration. The build process uses PowerShell or Git Bash.

For CUDA on Windows:

# Install CUDA Toolkit and set environment variables

$env:CUDA_PATH = "C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.0"
$env:PATH = "$env:CUDA_PATH\bin;$env:PATH"

# Force CUDA backend

$env:TAURI_GPU_FEATURE = "cuda"
pnpm run tauri:build

For Vulkan as a cross-platform fallback:

# Install Vulkan SDK

$env:VULKAN_SDK = "C:\VulkanSDK\1.3.211.0"
$env:BLAS_INCLUDE_DIRS = "$env:VULKAN_SDK\Include"

# Build with Vulkan compute shaders

$env:TAURI_GPU_FEATURE = "vulkan"
pnpm run tauri:build

Forcing Specific GPU Backends

When auto-detection fails or you need to target a specific backend for distribution, manually export TAURI_GPU_FEATURE before invoking the build scripts. This variable must match a feature defined in frontend/src-tauri/Cargo.toml.

Available backend flags:

• TAURI_GPU_FEATURE=cuda — NVIDIA cuBLAS acceleration
• TAURI_GPU_FEATURE=metal — Apple CoreML (macOS only)
• TAURI_GPU_FEATURE=vulkan — Vulkan compute pipelines
• TAURI_GPU_FEATURE=openblas — Optimized CPU inference

Example forcing Vulkan on Linux despite NVIDIA presence:

TAURI_GPU_FEATURE=vulkan ./frontend/build-gpu.sh

Troubleshooting Common Build Issues

Missing SDK Errors Drivers alone are insufficient. The build requires the full development toolkit (CUDA Toolkit, Vulkan SDK, or ROCm) to link against GPU libraries during Rust compilation.

Environment Variable Detection Failures If auto-detect-gpu.js cannot locate $CUDA_PATH or $VULKAN_SDK, it falls back to CPU mode. Explicitly set these variables in your shell profile or build script.

Feature Mismatch in Cargo.toml Verify that frontend/src-tauri/Cargo.toml contains the target feature in its [features] section. For example, ensure cuda = ["whisper-rs/cuda"] exists before setting TAURI_GPU_FEATURE=cuda. Without the feature definition in the manifest, Cargo ignores the environment variable.

Platform-Specific Linking Errors On Linux, ensure libcuda.so and libcublas.so are in your library path when building for CUDA. On Windows, verify that nvcc.exe is accessible from PowerShell before running the build.

Summary

• Meetily uses whisper-rs with Cargo features (cuda, metal, vulkan) to enable GPU transcription acceleration in the Tauri Rust core.
• The frontend/scripts/auto-detect-gpu.js script automatically selects the best backend by checking for nvidia-smi, vulkaninfo, and SDK environment variables.
• Set TAURI_GPU_FEATURE manually to override detection and force a specific backend before running dev-gpu.sh or build-gpu.sh.
• macOS builds default to Metal, Linux auto-detects CUDA then Vulkan, and Windows requires explicit CUDA or Vulkan SDK installation.
• Always verify that frontend/src-tauri/Cargo.toml contains the corresponding feature flags before attempting a GPU-specific build.

Frequently Asked Questions

How do I verify which GPU backend is actually running in my Meetily binary?

Check the console output during model loading. The whisper-rs crate logs the compute backend initialization. Alternatively, inspect the build artifacts in frontend/src-tauri/target/release/—the binary size will be significantly larger when linked with CUDA (~200MB+) compared to the CPU-only version (~50MB). You can also force a specific backend and verify transcription speed: GPU-accelerated inference processes audio 5-10x faster than CPU mode.

Can I distribute a single binary that supports multiple GPU backends?

No. According to the Meetily build architecture, the GPU backend is determined at compile time via Cargo features in Cargo.toml. Each backend requires different system libraries (cuBLAS for CUDA, CoreML for Metal, Vulkan loader for Vulkan). To support multiple backends, you must build separate binaries and distribute them accordingly, or ship the CPU-only version as a universal fallback.

Why does the auto-detect script fail to find my NVIDIA GPU on Linux?

The script in frontend/scripts/auto-detect-gpu.js checks for nvidia-smi and the CUDA_PATH environment variable. If either is missing, detection fails. Install the full CUDA Toolkit (not just drivers) and ensure /usr/local/cuda/bin is in your $PATH. For headless servers without nvidia-smi, manually set TAURI_GPU_FEATURE=cuda and ensure CUDA_PATH points to your installation directory.

Is Metal support available on Intel-based Macs?

Yes. The Metal backend in whisper-rs utilizes CoreML, which is available on both Apple Silicon and Intel Macs running macOS 10.14 or later. However, performance is significantly optimized for Apple Silicon (M1/M2/M3) chips. Intel Macs will see less dramatic speedups compared to CPU inference, but Metal is still the recommended backend for all macOS builds.

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