# Platform-Specific Audio Device Discovery in Meetily: Windows, macOS, and Linux Implementations

> Discover how Meetily finds audio devices on Windows (WASAPI), macOS (ScreenCaptureKit), and Linux (ALSA/PulseAudio) through a unified Tauri interface.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-08-02

---

**Meetily implements platform-specific audio device discovery using WASAPI on Windows, ScreenCaptureKit on macOS, and ALSA/PulseAudio on Linux, abstracted behind a unified `audio::devices` interface in the Tauri backend.**

Meetily is an open-source meeting assistant built with Tauri that requires robust cross-platform audio capture. The application handles **platform-specific audio device discovery** through dedicated modules in `frontend/src-tauri/src/audio/devices/platform/`, ensuring native API integration on each operating system while presenting a single, consistent Rust API to the frontend.

## Modular Architecture Overview

Meetily organizes audio device handling behind a modular `audio::devices` layer that isolates platform-specific code from the rest of the application. The architecture relies on two primary files to coordinate discovery:

- **[`frontend/src-tauri/src/audio/devices/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/mod.rs)** – Re-exports the platform-specific `discover_devices()` function using conditional compilation attributes (`#[cfg(target_os = "...")]`) to select the correct implementation at compile time.
- **[`frontend/src-tauri/src/audio/devices/discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/discovery.rs)** – Exposes the high-level public API `list_audio_devices()` that the UI and recording manager call to enumerate available microphones and system audio sources.

This design allows the rest of the codebase—including the recording manager in [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs)—to remain agnostic of the underlying native APIs.

## Windows Audio Device Discovery (WASAPI)

On Windows, Meetily leverages the **Windows Audio Session API (WASAPI)** for device enumeration and exclusive-mode handling. The implementation resides in [`frontend/src-tauri/src/audio/devices/platform/windows.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/platform/windows.rs).

This module queries the WASAPI subsystem to list all active capture and playback devices, returning structured data that includes device IDs, friendly names, and capabilities. The WASAPI implementation supports both shared-mode and exclusive-mode audio streams, enabling low-latency capture when required by the transcription pipeline.

## macOS Audio Device Discovery (ScreenCaptureKit and CoreAudio)

For macOS, the platform implementation in [`frontend/src-tauri/src/audio/devices/platform/macos.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/platform/macos.rs) utilizes **ScreenCaptureKit**—Apple’s modern framework for capturing system audio—combined with **CoreAudio** for microphone enumeration.

ScreenCaptureKit provides access to system audio streams (application audio and system output), while CoreAudio handles the discovery of physical input devices. This dual approach allows Meetily to present both microphone and system audio sources in the device selection UI, enabling users to record meeting audio from multiple sources simultaneously.

## Linux Audio Device Discovery (ALSA/PulseAudio)

The Linux implementation in [`frontend/src-tauri/src/audio/devices/platform/linux.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/platform/linux.rs) probes both **ALSA** and **PulseAudio** backends to ensure compatibility across different Linux distributions and audio server configurations.

During discovery, the module attempts to enumerate devices through PulseAudio first, falling back to ALSA hardware device enumeration when PulseAudio is unavailable. This hybrid approach ensures that Meetily can identify capture and playback devices on systems running traditional ALSA setups, modern PipeWire environments, or standard PulseAudio configurations.

## Implementation Flow and API Usage

When the Tauri frontend invokes the `start_recording` command, the backend executes a three-step discovery process:

1. **API Entry** – The call routes to `audio::devices::list_audio_devices()` in [`discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/discovery.rs).
2. **Platform Dispatch** – Conditional compilation directives select the appropriate platform module (Windows, macOS, or Linux) based on the target OS.
3. **Native Enumeration** – The platform-specific module queries the native API (WASAPI, ScreenCaptureKit, or ALSA/PulseAudio) and returns a `Vec<AudioDevice>` containing device names, unique IDs, and kinds (microphone versus system audio).

The `AudioDevice` struct serves as the universal data model across all platforms, containing fields for the device identifier, display name, and device type classification.

## Practical Code Examples

### Listing Available Devices (Rust)

```rust
use crate::audio::devices::list_audio_devices;

pub async fn show_device_picker() -> Result<(), anyhow::Error> {
    // Retrieve all devices for the current platform
    let devices = list_audio_devices()?;

    // Filter for microphone and system audio devices
    let microphones = devices.iter()
        .filter(|d| d.kind == AudioDeviceKind::Microphone)
        .collect::<Vec<_>>();

    let systems = devices.iter()
        .filter(|d| d.kind == AudioDeviceKind::System)
        .collect::<Vec<_>>();

    // Example: pick the first available device on each side
    let mic = microphones.first()
        .ok_or_else(|| anyhow!("No microphone found"))?
        .clone();
    let sys = systems.first()
        .ok_or_else(|| anyhow!("No system audio device found"))?
        .clone();

    // Pass the selections to the recording manager
    crate::audio::recording_manager::start(mic, sys).await?;
    Ok(())
}

```

### Direct Platform Access (For Testing)

```rust
#[cfg(target_os = "windows")]
fn dump_windows_devices() -> Result<(), anyhow::Error> {
    use crate::audio::devices::platform::windows::discover_devices;
    let devs = discover_devices()?;
    println!("Windows audio devices: {:#?}", devs);
    Ok(())
}

```

### Frontend Integration (TypeScript)

```typescript
import { invoke } from '@tauri-apps/api/tauri';

// Ask the Rust backend for the list of devices
async function populateDeviceSelectors() {
  const devices: AudioDevice[] = await invoke('list_audio_devices');
  // `AudioDevice` contains `{ id: string, name: string, kind: 'microphone' | 'system' }`
  setMicOptions(devices.filter(d => d.kind === 'microphone'));
  setSystemOptions(devices.filter(d => d.kind === 'system'));
}

```

## Summary

- **Windows** implements device enumeration via **WASAPI** in [`frontend/src-tauri/src/audio/devices/platform/windows.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/platform/windows.rs), supporting both shared and exclusive audio modes.
- **macOS** combines **ScreenCaptureKit** for system audio and **CoreAudio** for microphones in [`frontend/src-tauri/src/audio/devices/platform/macos.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/platform/macos.rs).
- **Linux** probes **ALSA and PulseAudio** backends in [`frontend/src-tauri/src/audio/devices/platform/linux.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/platform/linux.rs) for maximum distribution compatibility.
- The **unified API** `list_audio_devices()` in [`discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/discovery.rs) abstracts platform differences, returning standardized `AudioDevice` structs.
- **Conditional compilation** via `#[cfg(target_os = "...")]` in [`mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/mod.rs) ensures only the relevant platform code is included in the final binary.

## Frequently Asked Questions

### Which native APIs does Meetily use for audio device discovery on each platform?

Meetily uses **WASAPI** on Windows, **ScreenCaptureKit** (supplemented by CoreAudio for input devices) on macOS, and **ALSA/PulseAudio** on Linux. These APIs provide direct access to the operating system's audio hardware enumeration capabilities without requiring external dependencies.

### How does Meetily maintain cross-platform compatibility while using platform-specific audio APIs?

The codebase employs Rust's conditional compilation system through `#[cfg(target_os = "...")]` attributes in [`frontend/src-tauri/src/audio/devices/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/mod.rs). This approach selects the appropriate platform module at compile time, exposing a single `list_audio_devices()` function that works identically across Windows, macOS, and Linux.

### What information does Meetily return when discovering audio devices?

The `list_audio_devices()` function returns a vector of `AudioDevice` structs, where each struct contains the device's unique identifier, human-readable name, and device kind classification (either `Microphone` for input devices or `System` for system audio capture). This consistent data structure allows the frontend to populate device selection dropdowns without platform-specific logic.

### Where are the platform-specific audio implementations located in the Meetily repository?

Each platform implementation resides in `frontend/src-tauri/src/audio/devices/platform/` with dedicated files for each operating system: [`windows.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/windows.rs) for WASAPI, [`macos.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/macos.rs) for ScreenCaptureKit/CoreAudio, and [`linux.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/linux.rs) for ALSA/PulseAudio. The common discovery logic lives in [`frontend/src-tauri/src/audio/devices/discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/discovery.rs).