# Platform-Specific Audio Capture in Meetily: WASAPI, ScreenCaptureKit, and ALSA Implementation

> Explore Meetily's WASAPI, ScreenCaptureKit, and ALSA audio capture implementations. Learn how our modular Rust architecture achieves cross-platform audio capture with ease.

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

---

**Meetily implements platform-specific audio capture through a modular Rust architecture that abstracts WASAPI on Windows, Screen Capture Kit on macOS, and ALSA/PulseAudio on Linux into a unified cross-platform API.**

Meetily's audio subsystem relies on a sophisticated abstraction layer written in Rust to handle native audio APIs across operating systems. The implementation delegates platform-specific operations to dedicated modules while exposing a uniform interface for device enumeration and stream configuration. This design ensures low-latency audio capture for the application's local transcription pipeline regardless of the underlying operating system.

## Modular Architecture and Conditional Compilation

The audio device layer centers on **`cpal`** (Cross-Platform Audio Library) to minimize platform-specific code. Platform implementations reside in `frontend/src-tauri/src/audio/devices/platform/` and are conditionally compiled via [`platform/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/platform/mod.rs) based on `target_os` flags. The core entry point `list_audio_devices()` in [`discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/discovery.rs) instantiates a `cpal::Host` and delegates to the appropriate platform helper.

## Windows Audio Capture with WASAPI

On Windows, Meetily utilizes the **Windows Audio Session API (WASAPI)** for professional-grade low-latency capture.

### Device Enumeration and Loopback Configuration

The `configure_windows_audio()` function in [`platform/windows.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/platform/windows.rs) enumerates input and output devices through the WASAPI host. It distinguishes between microphone inputs and system audio outputs using WASAPI's loopback capabilities. When a user selects a device, `get_windows_device()` resolves the selection to a `cpal::Device` and selects a compatible `SupportedStreamConfig`.

```rust
use crate::audio::devices::platform::get_windows_device;
use crate::audio::devices::configuration::AudioDevice;

fn open_windows_device(selected: &AudioDevice) -> anyhow::Result<(cpal::Device, cpal::SupportedStreamConfig)> {
    // Resolve the CPAL device and a compatible config
    get_windows_device(selected)
}

```

## macOS Audio Capture with Screen Capture Kit

macOS implementation combines **Screen Capture Kit** for system audio and **CoreAudio** for microphone input.

### System Audio vs. Microphone Handling

The `configure_macos_audio()` function in [`platform/macos.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/platform/macos.rs) uses the default CPAL host to enumerate microphone inputs while filtering built-in speakers from the output list. For system audio capture, it leverages Screen Capture Kit's capabilities to capture application audio without requiring kernel extensions. This approach complies with macOS privacy requirements while maintaining high-quality audio streams.

## Linux Audio Capture with ALSA and PulseAudio

Linux support utilizes **ALSA** (Advanced Linux Sound Architecture) as the base layer with **PulseAudio** extensions for modern desktop environments.

### Monitor Sources for System Audio

The `configure_linux_audio()` function in [`platform/linux.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/platform/linux.rs) gathers microphone inputs via the default host and appends PulseAudio *monitor* sources to the device list. Monitor sources—identified by the "monitor" keyword in their names—represent system audio outputs that can be captured as inputs, enabling application audio recording alongside microphone input.

```rust
// In a Tauri command or any async context
use crate::audio::devices::discovery::list_audio_devices;

#[tauri::command]
async fn get_available_devices() -> Result<Vec<AudioDevice>, String> {
    list_audio_devices()
        .await
        .map_err(|e| format!("Failed to list audio devices: {}", e))
}

```

## Permission Handling and Pipeline Integration

Before capture begins, Meetily handles platform-specific permission requirements through `trigger_audio_permission()` in [`discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/discovery.rs). On macOS and Windows, this function constructs a short-lived input stream to provoke the operating system's permission dialog without starting actual recording.

Once permissions are granted, the **[`pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/pipeline.rs)** module receives raw audio chunks from the selected devices. It applies Voice Activity Detection (VAD) filtering, mixes microphone and system audio streams, and forwards the processed audio to the Whisper transcription engine using a standardized interface.

```rust
let device = /* obtained from platform helper */;
let config = /* chosen SupportedStreamConfig */;

let stream = device.build_input_stream(
    &config.clone().into(),
    move |data: &[f32], _: &cpal::InputCallbackInfo| {
        // Forward raw PCM to the pipeline for mixing/VAD
        audio_pipeline.process_mic_chunk(data);
    },
    |err| eprintln!("Audio stream error: {}", err),
    None,
)?;
stream.play()?; // Begins capturing

```

## Summary

- Meetily abstracts Windows WASAPI, macOS Screen Capture Kit, and Linux ALSA/PulseAudio through a unified Rust interface in `frontend/src-tauri/src/audio/devices/`.
- The [`discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/discovery.rs) module provides the public API via `list_audio_devices()` and `trigger_audio_permission()` functions.
- Platform-specific implementations in [`platform/windows.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/platform/windows.rs), [`platform/macos.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/platform/macos.rs), and [`platform/linux.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/platform/linux.rs) handle native API quirks while returning standard `cpal::Device` objects.
- Windows utilizes WASAPI loopback for system audio, macOS combines Screen Capture Kit with CoreAudio, and Linux leverages PulseAudio monitor sources.
- The [`pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/pipeline.rs) module consumes standardized audio streams for Voice Activity Detection and Whisper transcription regardless of the source platform.

## Frequently Asked Questions

### How does Meetily handle system audio capture differently on each platform?

On Windows, Meetily uses WASAPI loopback devices to capture system audio alongside microphone inputs. macOS implements Screen Capture Kit to record application audio without kernel extensions, while Linux utilizes PulseAudio monitor sources identified by the "monitor" keyword to tap into system audio outputs.

### What is the role of the cpal crate in Meetily's audio architecture?

The `cpal` crate provides the cross-platform foundation that abstracts host-specific audio APIs into a consistent Rust interface. Meetily's platform modules only need to handle OS-specific quirks like WASAPI loopback or PulseAudio monitors, while the higher-level [`pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/pipeline.rs) and recording logic remain portable across all supported operating systems.

### How does Meetily request audio permissions on macOS and Windows?

The `trigger_audio_permission()` function in [`discovery.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/discovery.rs) creates a temporary input stream to trigger the operating system's native permission dialog. This approach ensures compliance with macOS and Windows privacy requirements before the actual transcription pipeline begins capturing audio.

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

Platform-specific code resides in `frontend/src-tauri/src/audio/devices/platform/`, with [`windows.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/windows.rs) handling WASAPI, [`macos.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/macos.rs) implementing Screen Capture Kit and CoreAudio, and [`linux.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/linux.rs) managing ALSA and PulseAudio integration. These modules are conditionally compiled through [`platform/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/platform/mod.rs) based on the target operating system.