# GPU Acceleration Options for Meetily: Enabling CUDA, Vulkan, and Metal

> Explore Meetily's GPU acceleration with Metal, CUDA, and Vulkan. Optimize performance on macOS, Windows, and Linux using these powerful graphics APIs. Learn how to enable them.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: deep-dive
- Published: 2026-07-17

---

**Meetily supports GPU acceleration through Metal on macOS, CUDA on NVIDIA GPUs (Windows/Linux), and Vulkan on AMD/Intel GPUs (Linux), configured via Cargo feature flags at build time.**

The open-source Meetily transcription engine integrates OpenAI Whisper via Rust and can leverage GPU hardware to accelerate inference. According to the [Zackriya-Solutions/meetily](https://github.com/Zackriya-Solutions/meetily) source code, the GPU backend is selected at compile-time using Cargo features, with automatic fallback to CPU if GPU initialization fails.

## Supported GPU Backends by Platform

Meetily's transcription engine in `frontend/src-tauri/src/whisper_engine/` implements three distinct GPU acceleration paths. The appropriate backend is determined by your operating system and hardware vendor.

### Metal and Core ML on macOS

On **macOS 13 and later**, Meetily automatically uses **Metal** and **Core ML** for GPU acceleration. No additional Cargo flags are required during the build process. The engine detects Apple Silicon or compatible AMD GPUs through the Metal framework and initializes a `MetalEngine` context.

### CUDA for NVIDIA GPUs

**NVIDIA GPUs** on Windows and Linux require the `cuda` Cargo feature. When enabled, the build compiles the `CudaEngine` backend and links against NVIDIA's CUDA runtime. This path provides the fastest inference for supported discrete and datacenter GPUs.

### Vulkan for AMD and Intel GPUs

On **Linux**, **Vulkan** provides GPU acceleration for AMD and Intel graphics hardware. Enable this by compiling with the `vulkan` feature flag. The engine creates a `VulkanEngine` context using the Vulkan compute API, offering cross-platform GPU support without proprietary drivers.

## Build Configuration and Cargo Features

The GPU acceleration options are defined in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). The workspace exposes feature flags that propagate to the whisper engine crate:

```toml
[features]
default = []                       # CPU-only build

cuda = ["whisper_engine/cuda"]     # Enable NVIDIA CUDA

vulkan = ["whisper_engine/vulkan"] # Enable Vulkan (Linux/Windows)

```

When you compile with `--features cuda` or `--features vulkan`, the build system pulls in the corresponding GPU dependencies and compiles the hardware-specific inference 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).

## Runtime Selection Logic

The runtime selection logic resides in `whisper_engine::load_model` within [`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 initialization flow follows this hierarchy:

1. **Compile-time OS detection** using `cfg!(target_os = "macos")` and similar macros
2. **Feature flag validation** to check which GPU backends are compiled into the binary
3. **GPU context creation** attempting to initialize `CudaEngine`, `VulkanEngine`, or `MetalEngine`
4. **Graceful degradation** to `CpuEngine` if GPU runtime loading fails or hardware is unavailable

This design ensures that a single binary can be distributed with GPU support compiled in, but will still function on machines lacking suitable hardware or drivers.

## Build Commands and Examples

### Building with CUDA (NVIDIA on Linux or Windows)

Compile the Tauri application with CUDA support to enable NVIDIA GPU acceleration:

```bash
RUST_LOG=debug cargo tauri build --features cuda

```

### Building with Vulkan (AMD/Intel on Linux)

For AMD or Intel GPU acceleration on Linux systems, use the Vulkan feature:

```bash
RUST_LOG=debug cargo tauri build --features vulkan

```

### Building for macOS (Metal Auto-Detection)

On macOS, Metal support requires no special flags. Build normally:

```bash
cargo tauri build

```

### CPU-Only Build (CI or Non-GPU Machines)

Force a CPU-only build by disabling default features:

```bash
cargo tauri build --no-default-features

```

## Verifying GPU Initialization

To confirm which backend is active, run the application with debug logging enabled:

```bash
RUST_LOG=whisper_engine=debug ./clean_run.sh

```

Inspect the output for initialization messages:

```

[DEBUG] whisper_engine::acceleration] Using CUDA backend (GPU: NVIDIA RTX 3080)
[DEBUG] whisper_engine::acceleration] Falling back to CPU – no GPU detected

```

The frontend TypeScript API remains backend-agnostic. Call the model loader without specifying hardware:

```typescript
await invoke('load_whisper_model', { modelName: 'base' });

```

The Rust backend in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) handles the GPU context selection transparently.

## Summary

- **Metal** acceleration is automatic on macOS 13+ with no build flags required
- **CUDA** requires `cargo tauri build --features cuda` for NVIDIA GPUs on Windows and Linux
- **Vulkan** requires `cargo tauri build --features vulkan` for AMD/Intel GPUs on Linux
- Runtime selection logic in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) attempts GPU initialization and falls back to `CpuEngine` on failure
- Build configuration is managed through Cargo features in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml)

## Frequently Asked Questions

### Does Meetily automatically use GPU acceleration on all platforms?

No, automatic GPU acceleration only occurs on macOS via Metal. On Windows and Linux, you must explicitly compile with `--features cuda` or `--features vulkan` to include GPU support. The CPU-only build is the default to ensure compatibility across diverse hardware configurations.

### Can I use Vulkan on Windows for GPU acceleration?

While the Cargo.toml defines a `vulkan` feature that theoretically supports Windows, the Meetily source code primarily targets Vulkan for Linux AMD/Intel configurations. NVIDIA GPUs on Windows should use the CUDA backend for optimal performance and driver compatibility.

### What happens if GPU drivers are missing after building with GPU features?

Meetily implements graceful degradation in `whisper_engine::load_model`. If the compiled GPU backend (CUDA, Vulkan, or Metal) fails to initialize due to missing drivers or incompatible hardware, the engine automatically falls back to `CpuEngine` and continues transcription using CPU inference.

### Is Apple Silicon (M1/M2/M3) supported for GPU acceleration?

Yes, Apple Silicon Macs automatically use Metal and Core ML acceleration when running macOS 13 or later. The engine detects the Apple GPU architecture through the Metal framework and initializes the appropriate `MetalEngine` context without requiring manual configuration.