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

> Discover Meetily's GPU acceleration backends: Metal CUDA Vulkan HIP BLAS. Learn how they are detected and selected for optimal performance.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: internals
- Published: 2026-07-18

---

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

```rust
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/acceleration.rs), this logic controls both GPU utilization and flash-attention optimization:

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

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

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