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

> Build Meetily with GPU acceleration using CUDA Vulkan or Metal by enabling Cargo features or using the build-gpu.sh script for faster performance.

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

---

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

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

```bash
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:

```bash

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

```bash
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:

```bash
cargo build --release --features metal

```

### Windows

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

```bash

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

```bash
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml), not at runtime.
- **Helper script**: Use [`./frontend/build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.