What GPU Acceleration Backends Does Meetily Support and How Are They Detected?

Meetily supports Metal (Apple Silicon), CUDA (NVIDIA), Vulkan (AMD/Intel), and HIP BLAS (AMD ROCm) GPU acceleration backends, which are selected at compile time via Cargo feature flags and validated at runtime through environment and hardware detection in hardware_detector.rs.

Meetily, an open-source meeting transcription application from Zackriya-Solutions/meetily, leverages GPU acceleration to optimize Whisper model inference. Understanding what GPU acceleration backends Meetily supports and how they are detected is essential for deploying the application across diverse hardware environments. The system uses a two-stage selection process that combines compile-time feature flags with runtime hardware probing to determine the optimal inference path.

Supported GPU Acceleration Backends in Meetily

Meetily's Whisper engine can target multiple GPU compute APIs, each enabled through specific Cargo features and targeted at distinct hardware vendors.

Metal for Apple Silicon

The Metal backend targets Apple Silicon devices running macOS. This backend is automatically selected on macOS systems when the metal feature is enabled or when no competing GPU feature is specified during compilation. Runtime detection validates the aarch64 architecture and confirms Metal driver availability through system environment checks in has_metal_support().

CUDA for NVIDIA GPUs

The CUDA backend supports NVIDIA GPUs with properly installed CUDA drivers and toolkits. Compile-time selection requires the cuda feature flag. At runtime, has_cuda_support() inspects the CUDA_PATH and CUDA_HOME environment variables, or verifies the existence of /usr/local/cuda on Unix-based systems to confirm driver availability.

Vulkan for Cross-Platform Compatibility

The Vulkan backend provides support for AMD, Intel, and other GPUs with Vulkan-compatible drivers. Enabled via the vulkan feature, this backend uses has_vulkan_support() to check for the VULKAN_SDK environment variable on Linux or scan for vulkan-1.dll on Windows systems to verify the Vulkan loader is present.

HIP BLAS for AMD ROCm

The HIP BLAS backend targets AMD GPUs using the ROCm platform. Selection occurs exclusively through the hipblas compile-time feature. Unlike other backends, runtime detection for HIP BLAS relies primarily on the compiled backend configuration rather than extensive environment probing, falling back to CPU inference if ROCm libraries are unavailable at runtime.

CPU Fallback

When no GPU feature flags are enabled during compilation, or when runtime detection fails to identify compatible hardware, Meetily falls back to CPU-only inference. This ensures the application remains functional across all supported platforms regardless of GPU capabilities, though transcription performance will be significantly reduced compared to accelerated paths.

Compile-Time Backend Selection

The WhisperCompiledBackend::current() function in frontend/src-tauri/src/whisper_engine/acceleration.rs determines which GPU backend the binary was built to support. This compile-time logic evaluates Cargo feature flags in priority order:

if cfg!(feature = "cuda") { Self::Cuda }
else if cfg!(feature = "vulkan") { Self::Vulkan }
else if cfg!(feature = "hipblas") { Self::HipBlas }
else if cfg!(target_os = "macos") || cfg!(feature = "metal") { Self::Metal }
else { Self::Cpu }

This architecture ensures that the binary contains only the code paths relevant to the targeted GPU stack, reducing binary size and eliminating runtime dependencies on unsupported APIs.

Runtime GPU Detection Mechanisms

When the application initializes, HardwareProfile::detect() in frontend/src-tauri/src/audio/hardware_detector.rs executes detect_gpu() to probe the host system and validate that the compiled backend can actually be utilized.

The detection process follows this hierarchical approach:

• Metal Detection – Validates the target architecture is aarch64 and confirms macOS environment variables indicative of Metal support.
• CUDA Detection – Inspects environment variables (CUDA_PATH, CUDA_HOME) and filesystem paths (/usr/local/cuda) to confirm NVIDIA driver and toolkit availability.
• Vulkan Detection – Checks for VULKAN_SDK environment variables on Linux or scans for vulkan-1.dll on Windows to verify loader presence.

If none of these checks succeed, the system sets has_gpu_acceleration = false and gpu_type = GpuType::None, forcing the application to use CPU inference regardless of compile-time configuration.

Acceleration Decision Logic and Flash-Attention

The whisper_context_acceleration_for() function combines the compiled backend, runtime-detected GPU type, and performance tier to determine optimal inference parameters. Located in frontend/src-tauri/src/whisper_engine/acceleration.rs, this logic controls both GPU utilization and flash-attention optimization:

let use_gpu = !matches!(compiled_backend, WhisperCompiledBackend::Cpu);
let fast_tier = matches!(performance_tier, PerformanceTier::High | PerformanceTier::Ultra);
let flash_attn = matches!(compiled_backend, WhisperCompiledBackend::Metal | WhisperCompiledBackend::Cuda) && fast_tier;

GPU usage is enabled unless the compiled backend is Cpu. Flash-attention—a memory-efficient attention mechanism that reduces VRAM usage and increases speed—is restricted to Metal and CUDA backends, and only activates when the detected performance tier is High or Ultra. Vulkan and HIP BLAS backends never enable flash-attention, even on capable hardware.

Practical Implementation Examples

To leverage these detection mechanisms in custom integrations, you can query the hardware profile and initialize the appropriate Whisper context:

use crate::audio::HardwareProfile;

fn log_hardware() {
    let profile = HardwareProfile::detect();
    log::info!(
        "CPU cores: {}, GPU: {:?} (acceleration: {}), Memory: {} GB, Tier: {:?}",
        profile.cpu_cores,
        profile.gpu_type,
        profile.has_gpu_acceleration,
        profile.memory_gb,
        profile.performance_tier,
    );
}

When creating the transcription context, combine the compiled backend with runtime detection:

use crate::whisper_engine::{whisper_context_acceleration_for, WhisperCompiledBackend};
use crate::audio::{HardwareProfile, PerformanceTier};

fn create_whisper_context() {
    let hw = HardwareProfile::detect();
    let compiled = WhisperCompiledBackend::current();

    let accel = whisper_context_acceleration_for(
        compiled,
        hw.gpu_type,
        hw.performance_tier,
    );

    log::info!("Whisper acceleration: {}", accel.status_label());
    // Pass `accel` to the Whisper engine initializer…
}

Summary

• Meetily supports Metal, CUDA, Vulkan, and HIP BLAS GPU acceleration backends, plus a CPU fallback option.
• Compile-time selection occurs via Cargo feature flags (cuda, vulkan, hipblas, metal) evaluated in WhisperCompiledBackend::current().
• Runtime detection validates hardware availability through HardwareProfile::detect() in hardware_detector.rs, checking environment variables and system paths specific to each GPU vendor.
• Flash-attention is exclusively available on Metal and CUDA backends when running on High or Ultra performance tier hardware.
• The system gracefully degrades to CPU inference when GPU detection fails or when no GPU features are compiled into the binary.

Frequently Asked Questions

Does Meetily automatically switch between GPU backends at runtime?

No, the GPU backend is fixed at compile time based on Cargo feature flags in WhisperCompiledBackend::current(). While runtime detection determines if the compiled backend can actually be used via HardwareProfile::detect(), you cannot switch from CUDA to Vulkan without recompiling the application with different feature flags.

Why doesn't Vulkan support flash-attention in Meetily?

According to the source code in frontend/src-tauri/src/whisper_engine/acceleration.rs, flash-attention is explicitly restricted to WhisperCompiledBackend::Metal and WhisperCompiledBackend::Cuda variants. The implementation currently excludes Vulkan and HIP BLAS from flash-attention optimization regardless of hardware capabilities or performance tier classifications.

How does Meetily handle systems with multiple GPUs?

Meetily's detection logic in hardware_detector.rs identifies the presence of GPU acceleration support through environment variables like CUDA_PATH or VULKAN_SDK, but does not implement explicit multi-GPU selection logic. The underlying Whisper implementation typically utilizes the default or primary GPU detected by the respective driver stack.

Can I use GPU acceleration on Windows with AMD GPUs?

Yes, you can enable AMD GPU support on Windows by compiling Meetily with the vulkan feature flag. Runtime detection will check for vulkan-1.dll to confirm driver availability. Note that flash-attention will not be available with Vulkan backend acceleration, and performance characteristics may differ from native CUDA or Metal implementations.

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