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

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 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. The workspace exposes feature flags that propagate to the whisper engine crate:

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

Runtime Selection Logic

The runtime selection logic resides in whisper_engine::load_model within 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:

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:

RUST_LOG=debug cargo tauri build --features vulkan

Building for macOS (Metal Auto-Detection)

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

cargo tauri build

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

Force a CPU-only build by disabling default features:

cargo tauri build --no-default-features

Verifying GPU Initialization

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

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:

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

The Rust backend in 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 attempts GPU initialization and falls back to CpuEngine on failure
• Build configuration is managed through Cargo features in 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.

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