# Voice Activity Detection (VAD) Role in Meetily's Transcription Pipeline

> Voice Activity Detection VAD cleans audio streams in Meetily's transcription pipeline, ensuring Whisper receives clear speech segments for accurate transcription.

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

---

**Voice Activity Detection (VAD) serves as the decisive gatekeeper in Meetily's transcription pipeline, isolating genuine speech from mixed audio streams before delivering clean, validated segments to the Whisper transcription engine.**

In the open-source meeting assistant **Zackriya-Solutions/meetily**, VAD is the architectural cornerstone that determines transcription quality and resource efficiency. By processing dual audio streams through a Silero-based detection algorithm, Meetily ensures that only voice activity—free from silence and background noise—reaches the GPU-intensive Whisper model.

## How VAD Integrates into Meetily's Dual-Stream Architecture

Meetily captures audio through two parallel inputs: microphone input (user speech) and system audio (shared screen sound). These streams are mixed into a continuous 48 kHz feed before entering the VAD processor.

The VAD implementation in [`frontend/src-tauri/src/audio/vad.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/vad.rs) (lines 33–65) handles real-time resampling and segmentation. It converts the incoming 48 kHz mixed signal into 16 kHz chunks of 30 ms duration (480 samples each). This resampling step is critical because the underlying Silero VAD model requires 16 kHz input, while the system otherwise operates at higher fidelity for audio capture.

Once resampled, the audio flows into [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) (lines 678–735), where the VAD-driven logic replaces traditional time-based chunking. Instead of splitting audio into arbitrary 2-second blocks, the pipeline uses actual voice detection to determine segment boundaries, ensuring that transcription only occurs during active speech.

## Three Core Responsibilities of VAD in the Transcription Path

### Speech-Only Segmentation and Noise Filtering

The primary function of VAD is to convert continuous audio into discrete speech segments. In [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) (lines 678–735), the processor analyzes each 30 ms window to classify sound as speech or non-speech. Silence and background noise are aggressively filtered out at this stage.

This segmentation prevents the Whisper engine from attempting to transcribe silent periods, which significantly reduces **hallucinations**—erroneous text generation when processing noise or dead air. By stripping non-speech audio before transcription, Meetily reduces the data volume sent to Whisper by substantial margins.

### Dynamic Chunking Using Redemption Time

Unlike earlier implementations that relied on fixed `target_chunk_duration_ms` intervals, Meetily's VAD-driven pipeline employs a "redemption time" mechanism. As implemented in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) (lines 722–731), the system uses a default **2000 ms** redemption window to bridge natural pauses in conversation.

This means that brief silences within a sentence do not trigger premature transcription sends. Instead, VAD maintains the current speech segment across short gaps, producing longer, linguistically coherent chunks that improve Whisper's contextual understanding and transcription accuracy.

### Direct Pre-Filtering for the Whisper Engine

Once VAD confirms a speech segment is complete, it dispatches the audio directly to the transcription worker without any additional silence pruning. The pipeline code in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) (lines 841–858) logs each segment's precise duration and sample count before calling `whisper_engine.transcribe()`.

This direct handoff guarantees that Whisper receives only validated speech samples, eliminating redundant CPU cycles that would otherwise process silence. The implementation ensures that the `whisper_engine` operates exclusively on high-quality, speech-only audio buffers.

## Implementation Walkthrough: From Raw Audio to Transcription

The VAD processor is instantiated with specific sample rate configurations to handle the mixed audio stream:

```rust
let vad = VadProcessor::new(
    input_sample_rate,            // 48 kHz mixed audio from mic + system
    VAD_SAMPLE_RATE,              // 16 kHz required by Silero VAD
    VAD_REDEMPTION_TIME_MS,       // 2000 ms bridges natural pauses
)?;

```

The pipeline executes the VAD-driven workflow asynchronously, managing the flow from capture to transcription:

```rust
info!("VAD-driven audio pipeline started");
pipeline.run_vad().await?;
info!("VAD-driven audio pipeline ended");

```

When a speech segment is finalized, it is immediately sent to the transcription engine with metadata logging:

```rust
info!(
    "📤 Sending VAD segment: {:.1}ms, {} samples",
    segment.duration_ms(),
    segment.sample_count()
);
whisper_engine.transcribe(segment).await?;

```

## Performance Impact and Accuracy Benefits

By positioning VAD as the first processing layer, Meetily achieves significant computational savings. The Whisper model avoids processing silent frames, resulting in lower GPU and CPU utilization during meetings with substantial dead air or pause-heavy dialogue.

Additionally, the VAD-driven approach produces more natural transcript segmentation. Because chunks align with actual speech boundaries rather than arbitrary time slices, Whisper receives complete phrases and sentences, improving recognition accuracy for context-dependent words and technical terminology.

## Summary

- **VAD acts as a gatekeeper** in [`frontend/src-tauri/src/audio/vad.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/vad.rs), filtering mixed 48 kHz audio into 16 kHz speech segments before Whisper processing.
- **Dynamic redemption time** (default 2000 ms) in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) bridges natural pauses, creating linguistically coherent chunks instead of arbitrary time slices.
- **Pre-filtering eliminates hallucinations** by ensuring the transcription engine in [`frontend/src-tauri/src/audio/transcription/worker.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/transcription/worker.rs) receives only validated speech, reducing computational overhead and improving accuracy.
- **Silero-based detection** processes audio in 30 ms windows (480 samples at 16 kHz), enabling real-time decision-making with minimal latency.

## Frequently Asked Questions

### What is the primary purpose of VAD in Meetily?

The primary purpose is to isolate genuine speech from mixed audio streams containing silence, background noise, and system sounds. By filtering audio before it reaches the Whisper engine, VAD prevents transcription hallucinations and reduces the computational load on GPU resources.

### How does Meetily's VAD handle natural pauses in speech?

Meetily implements a "redemption time" of 2000 ms as configured in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) (lines 722–731). This buffer allows the system to maintain speech segmentation across brief silences within sentences, ensuring that natural conversational pauses do not split related phrases into separate transcription chunks.

### What audio sample rates does Meetily's VAD processor use?

The system captures mixed audio at 48 kHz but immediately resamples to 16 kHz for VAD processing, as required by the Silero VAD model. The processor analyzes audio in 30 ms chunks containing 480 samples at the 16 kHz rate, as defined in [`frontend/src-tauri/src/audio/vad.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/vad.rs) (lines 33–65).

### Where is the VAD logic implemented in the Meetily codebase?

The core VAD implementation resides in [`frontend/src-tauri/src/audio/vad.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/vad.rs), which handles the Silero-based detection and resampling. The integration with the broader audio pipeline occurs in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs), while [`frontend/src-tauri/src/audio/transcription/worker.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/transcription/worker.rs) receives the filtered segments for Whisper processing.