# How Meetily Implements Cross-Platform GPU Acceleration: Metal, CUDA, and Vulkan Support

> Discover how Meetily achieves seamless cross-platform GPU acceleration using Metal CUDA and Vulkan. Learn about its smart runtime hardware detection and compile time feature flags for optimal performance.

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

---

**Meetily combines compile-time feature flags with runtime hardware detection to automatically configure the optimal GPU backend across macOS, Windows, and Linux without manual intervention.**

Meetily, the open-source meeting transcription tool from Zackriya-Solutions/meetily, delivers cross-platform GPU acceleration through a hybrid architecture that bridges Rust's conditional compilation with dynamic system profiling. The implementation centers on the `whisper_rs` transcription engine, which targets platform-specific graphics APIs while maintaining a unified interface for CPU fallback. By leveraging Cargo features and hardware detection modules, Meetily automatically selects Metal on Apple devices, CUDA on NVIDIA hardware, or Vulkan for portable GPU compute.

## Compile-Time Backend Selection via Feature Flags

The foundation of Meetily's GPU acceleration strategy resides in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml), where optional features declare support for each graphics API. These features forward to the underlying `whisper-rs` crate, ensuring only the necessary backend code is compiled into the binary.

The available feature flags include:

```toml

# frontend/src-tauri/Cargo.toml

[features]
metal = ["whisper-rs/metal"]
cuda  = ["whisper-rs/cuda"]
vulkan = ["whisper-rs/vulkan"]
hipblas = ["whisper-rs/hipblas"]
coreml = ["whisper-rs/coreml"]

```

Platform-specific defaults in the [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) automatically enable the most appropriate backend for the target OS. **macOS** builds default to `metal` (and `coreml` for Apple Silicon), while **Windows and Linux** builds default to `openblas` for CPU-only operation unless the developer explicitly enables `cuda`, `vulkan`, or `hipblas` during compilation.

## Runtime GPU Detection and Hardware Profiling

After compilation, Meetily determines actual hardware capabilities through the [`hardware_detector.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/hardware_detector.rs) module at [`frontend/src-tauri/src/audio/hardware_detector.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/hardware_detector.rs). This component constructs a `HardwareProfile` by inspecting the operating system and environment variables to identify the available GPU type.

The detection logic specifically checks for:
- **Metal** frameworks on macOS
- **CUDA** installations via `CUDA_PATH` or `CUDA_HOME` environment variables
- **Vulkan** SDKs through `VULKAN_SDK` or system libraries (`/usr/lib/libvulkan.so`, `vulkan-1.dll`)

The returned `HardwareProfile` contains:
- `has_gpu_acceleration`: Boolean flag for GPU availability
- `gpu_type`: Enum variant (`Metal`, `Cuda`, `Vulkan`, `OpenCL`, or `None`)
- `performance_tier`: Resource classification from Low to Ultra based on CPU cores and memory

## Mapping Compile-Time Backends to Runtime Configuration

The critical integration point between build features and hardware detection resides 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 module defines the `WhisperCompiledBackend` enum and the `whisper_context_acceleration_for` function, which synthesizes compile-time capabilities with runtime discovery.

The function accepts three parameters:
1. **Compiled backend**: Which feature was enabled at build time (`Metal`, `Cuda`, `Vulkan`, `HipBlas`, or `Cpu`)
2. **Runtime GPU**: The `GpuType` detected by the hardware profiler
3. **Performance tier**: System classification derived from available resources

It returns a `WhisperContextAcceleration` struct configuring:
- `use_gpu`: Enabled when the compiled backend matches detected hardware
- `flash_attn`: Automatically activated for **Metal** and **CUDA** backends when the performance tier is High or Ultra
- `gpu_device`: Currently defaults to `0` (first available device)

The selection logic implements the following rules:

```rust
let use_gpu = !matches!(compiled_backend, WhisperCompiledBackend::Cpu);
let fast_tier = matches!(performance_tier, PerformanceTier::High | PerformanceTier::Ultra);
let flash_attn = match compiled_backend {
    WhisperCompiledBackend::Metal | WhisperCompiledBackend::Cuda => fast_tier,
    _ => false,
};

```

## Engine Initialization and Backend Activation

When `WhisperEngine` initializes 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), the constructor invokes `detect_gpu_acceleration()` to log the active configuration and initialize the whisper-rs context. The engine prints diagnostic output indicating whether Metal, CUDA, Vulkan, or CPU-only mode is active, conditioned on the compile-time features present in the binary.

This architecture ensures that a macOS build automatically reports Metal acceleration, while a Windows build compiled without GPU features reports "CPU only" regardless of underlying hardware capabilities.

## Practical Implementation Examples

To inspect hardware capabilities programmatically:

```rust
use crate::audio::hardware_detector::HardwareProfile;

let profile = HardwareProfile::detect();
println!(
    "GPU: {:?}, cores: {}, tier: {:?}",
    profile.gpu_type, profile.cpu_cores, profile.performance_tier
);

```

To create an engine instance with automatic backend selection:

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

let engine = WhisperEngine::new()?; // Logs active backend (Metal, CUDA, Vulkan, etc.)

```

To manually configure acceleration settings:

```rust
use meetily::frontend::src_tauri::whisper_engine::{
    acceleration::{whisper_context_acceleration_for, WhisperCompiledBackend},
    GpuType, PerformanceTier,
};

let compiled = WhisperCompiledBackend::Cuda;
let runtime = GpuType::Cuda;
let tier = PerformanceTier::High;

let accel = whisper_context_acceleration_for(compiled, runtime, tier);
println!(
    "Using GPU: {}, FlashAttention: {}",
    accel.use_gpu, accel.flash_attn
);

```

## Summary

- **Feature flags** in [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) (`metal`, `cuda`, `vulkan`) determine which GPU backends are compiled into the Meetily binary
- **Runtime detection** in [`hardware_detector.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/hardware_detector.rs) identifies the actual GPU type by checking environment variables and system libraries across platforms
- The `whisper_context_acceleration_for` function in [`acceleration.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/acceleration.rs) maps compiled backends to detected hardware, automatically enabling **Flash-Attention** for high-performance Metal and CUDA devices
- **Platform defaults** ensure macOS builds target Metal automatically, while Windows and Linux require explicit feature selection for GPU support
- **Engine initialization** in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) validates the configuration and initializes the whisper-rs context with the detected acceleration settings

## Frequently Asked Questions

### How does Meetily choose between Metal, CUDA, and Vulkan?

Meetily employs a two-stage selection process. First, **compile-time feature flags** in [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/Cargo.toml) restrict which backends are available in the compiled binary. Second, the [`hardware_detector.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/hardware_detector.rs) module performs **runtime detection** to identify which GPU is physically present on the host. The engine only enables acceleration when the compiled backend and detected hardware type match, falling back to CPU operation otherwise.

### Can Meetily use GPU acceleration without an NVIDIA graphics card?

Yes. Meetily supports **Metal** for Apple Silicon and Intel Macs, **Vulkan** for AMD and Intel graphics on Windows/Linux, and **HIPBLAS** for AMD ROCm-compatible hardware. The [`hardware_detector.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/hardware_detector.rs) module checks for these alternatives by inspecting Metal frameworks on macOS or Vulkan libraries (`libvulkan.so`, `vulkan-1.dll`) on other platforms, enabling acceleration on diverse hardware configurations.

### What is Flash-Attention and when does Meetily enable it?

**Flash-Attention** is a memory-efficient attention mechanism that reduces computational overhead during transcription. According to the source code in [`acceleration.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/acceleration.rs), Meetily automatically enables Flash-Attention when the compiled backend is **Metal** or **CUDA** and the `HardwareProfile` reports a **High** or **Ultra** performance tier. This optimization remains disabled for CPU-only operation and Vulkan backends to ensure compatibility and stability.

### How can I verify which GPU backend is active at runtime?

When initializing the `WhisperEngine`, the `detect_gpu_acceleration()` method in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) prints a diagnostic log line indicating the active backend. You can also programmatically verify the configuration by calling `HardwareProfile::detect()` from [`hardware_detector.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/hardware_detector.rs), which returns the specific `GpuType` variant detected on your system, or by inspecting the `WhisperContextAcceleration` struct returned by `whisper_context_acceleration_for`.