# How to Configure GPU Acceleration for Whisper Transcription in Meetily: A Complete Guide

> Learn how to configure GPU acceleration for Whisper transcription in Meetily. This guide details compiling the Tauri frontend with the right Cargo feature flag for optimal performance.

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

---

**Meetily automatically enables GPU acceleration for Whisper transcription by detecting your hardware at runtime, but you must compile the Tauri frontend with the correct Cargo feature flag (`cuda`, `metal`, `vulkan`, or `hipblas`) for your specific GPU architecture.**

Meetily is an open-source meeting transcription application built with Tauri and Rust that leverages OpenAI's Whisper models for accurate speech-to-text conversion. While the application automatically detects available GPU hardware, configuring GPU acceleration requires understanding both compile-time feature flags and runtime initialization parameters. This guide walks through the exact steps to enable NVIDIA CUDA, Apple Metal, Vulkan, or AMD ROCm support based on the actual implementation in the Meetily codebase.

## Compile-Time Configuration with Cargo Features

The GPU backend selection happens at compile time through feature flags defined in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). These features map directly to the backends supported by the underlying `whisper-rs` crate.

### Available GPU Backend Features

Meetily supports five distinct compute backends through optional Cargo features:

- **`metal`** — Apple Metal GPU acceleration for macOS Apple Silicon
- **`cuda`** — NVIDIA CUDA support for Windows and Linux
- **`vulkan`** — Vulkan compute for AMD/Intel GPUs on Windows/Linux
- **`hipblas`** — AMD ROCm/HIP-BLAS for Linux AMD GPUs
- **`openblas`** / **`openmp`** — Optimized CPU fallbacks

These features are declared in the Cargo manifest:

```toml
[features]
metal = ["whisper-rs/metal"]
coreml = ["whisper-rs/coreml"]
cuda = ["whisper-rs/cuda"]
vulkan = ["whisper-rs/vulkan"]
hipblas = ["whisper-rs/hipblas"]
openblas = ["whisper-rs/openblas"]
openmp = ["whisper-rs/openmp"]

```

### Platform-Specific Build Commands

Enable GPU acceleration by building with the appropriate feature flag for your hardware:

```bash

# macOS - Metal and CoreML are auto-enabled

cargo build --release

# Windows with NVIDIA GPU

cargo build --release --features cuda

# Linux with NVIDIA GPU

cargo build --release --features cuda

# Linux with AMD GPU (ROCm)

cargo build --release --features hipblas

# Windows/Linux with Vulkan-compatible GPU (AMD/Intel)

cargo build --release --features vulkan

```

The selected feature determines which variant `WhisperCompiledBackend::current()` returns, as implemented in [`frontend/src-tauri/src/whisper_engine/acceleration.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/acceleration.rs) (lines 13-25).

## Runtime Hardware Detection and Configuration

After compilation, Meetily's `WhisperEngine` automatically probes the host system to confirm GPU availability and configure optimal parameters.

### Automatic GPU Detection

When `WhisperEngine::new()` initializes (lines 79-86 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)), it calls `detect_gpu_acceleration()` to check the compiled backend:

```rust
let gpu_support = Self::detect_gpu_acceleration();
log::info!("Hardware acceleration support: {}", gpu_support);

```

The detection logic matches the compiled backend:

```rust
match WhisperCompiledBackend::current() {
    WhisperCompiledBackend::Metal => true,
    WhisperCompiledBackend::Cuda => true,
    WhisperCompiledBackend::Vulkan => true,
    WhisperCompiledBackend::HipBlas => true,
    WhisperCompiledBackend::Cpu => false,
}

```

### Adaptive Performance Configuration

Beyond simple detection, `HardwareProfile::detect()` in [`frontend/src-tauri/src/audio/hardware_detector.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/hardware_detector.rs) (lines 84-102) performs detailed profiling of CPU cores, GPU type, and available RAM. This produces an `AdaptiveWhisperConfig` that sets **beam size**, **temperature**, **thread count**, and whether to **use the GPU** with **Flash Attention**.

The configuration is applied when loading the model:

```rust
let acceleration = whisper_context_acceleration_for(
    WhisperCompiledBackend::current(),
    hardware_profile.gpu_type,
    hardware_profile.performance_tier,
);

let context_param = WhisperContextParameters {
    use_gpu: acceleration.use_gpu,
    gpu_device: acceleration.gpu_device,
    flash_attn: acceleration.flash_attn,
    ..Default::default()
};

```

## Overriding Automatic GPU Selection

You can force specific behavior by manually constructing `WhisperContextParameters` before creating the Whisper context.

### Force CPU-Only Mode

To disable GPU acceleration even when available:

```rust
use whisper_rs::{WhisperContextParameters, WhisperContext};

let mut params = WhisperContextParameters::default();
params.use_gpu = false;

let ctx = WhisperContext::new_with_params(&model_path, params)?;

```

### Force Specific GPU Device

To explicitly select a GPU device index:

```rust
let mut params = WhisperContextParameters::default();
params.use_gpu = true;
params.gpu_device = 0; // Use first GPU

let ctx = WhisperContext::new_with_params(&model_path, params)?;

```

## Debugging and Environment Variables

Meetily suppresses verbose whisper.cpp logs by default. Adjust these environment variables for troubleshooting:

```rust
std::env::set_var("GGML_METAL_LOG_LEVEL", "1"); // 0=off, 1=error, 2=warn, 3=info
std::env::set_var("WHISPER_LOG_LEVEL", "1");

```

Ensure system-level environment variables are set for runtime detection:
- **`CUDA_PATH`** for NVIDIA GPUs
- **`VULKAN_SDK`** for Vulkan backends
- **`/usr/local/cuda`** presence for Linux CUDA systems

## Complete Implementation Example

Here's the typical initialization flow that automatically applies GPU acceleration:

```rust
use meetily::frontend::src_tauri::whisper_engine::WhisperEngine;

#[tokio::main]
async fn main() -> Result<()> {
    // Build with: cargo build --release --features cuda
    
    // Initialize engine with automatic hardware detection
    let engine = WhisperEngine::new()?;
    
    // Download and load model with GPU-aware parameters
    engine.download_model("small", None).await?;
    engine.load_model("small").await?;
    
    // Transcribe using GPU acceleration
    let audio: Vec<f32> = /* microphone capture */;
    let (text, confidence, _) = engine
        .transcribe_audio_with_confidence(audio, Some("auto".into()))
        .await?;
        
    Ok(())
}

```

## Summary

- **Compile with the correct feature flag**: Use `--features cuda`, `--features metal`, `--features vulkan`, or `--features hipblas` when building to include GPU support in the binary.
- **Automatic runtime detection**: `WhisperEngine::new()` automatically probes for GPU hardware and configures `WhisperContextParameters` based on your system's capabilities.
- **Adaptive quality**: The engine adjusts beam size, temperature, and thread count based on the detected `PerformanceTier` (Low/Medium/High/Ultra).
- **Manual override**: You can force CPU or GPU mode by manually setting `use_gpu` and `gpu_device` in `WhisperContextParameters`.
- **Environment setup**: Ensure `CUDA_PATH` or `VULKAN_SDK` are set for proper runtime detection.

## Frequently Asked Questions

### Why is Meetily not using my GPU even after compiling with CUDA features?

If Meetily falls back to CPU transcription after building with `--features cuda`, verify that the `CUDA_PATH` environment variable is set and that NVIDIA drivers are properly installed. The runtime detection logic in [`hardware_detector.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/hardware_detector.rs) checks for these environment markers. You can also check the application logs at startup to see which `WhisperCompiledBackend` was detected.

### Can I use GPU acceleration on macOS with Intel processors?

Intel-based Macs can use GPU acceleration through the `coreml` feature for Apple Neural Engine support on compatible models, or fall back to optimized CPU backends. The `metal` feature specifically targets Apple Silicon (M1/M2/M3) GPUs. Compile with `cargo build --release` to automatically enable the appropriate macOS backends according to your hardware.

### How do I verify which GPU backend is active in Meetily?

Check the application logs at startup for the line logged by `WhisperEngine::new()` indicating "Hardware acceleration support". You can also programmatically inspect the backend using `WhisperCompiledBackend::current()`, which returns the variant (`Metal`, `Cuda`, `Vulkan`, `HipBlas`, or `Cpu`) that was compiled into the binary.

### Is it possible to switch between GPU and CPU mode without recompiling?

Yes, runtime switching is possible by modifying the `use_gpu` field in `WhisperContextParameters` before initializing the Whisper context. However, the binary must still be compiled with the corresponding GPU feature flag to include the necessary backend code. Without compiling with `cuda` or other GPU features, the GPU code paths are not included in the final binary.