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

> Build GPU-specific Meetily Tauri binaries for Metal, CUDA, or Vulkan backends by setting the TAURI_GPU_FEATURE environment variable. Learn how to optimize your Meetily app with hardware acceleration.

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

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/scripts/auto-detect-gpu.js), a Node.js script invoked by [`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). 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:

```bash
./frontend/build-gpu.sh

```

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

```bash
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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):

```bash

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

```bash

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

```bash

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

```powershell

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

```powershell

# 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

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