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

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

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

# 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 (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), it calls detect_gpu_acceleration() to check the compiled backend:

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

The detection logic matches the compiled backend:

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

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:

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:

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:

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:

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 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.

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