Is Meetily a Real-Time Application? Technical Architecture Analysis

Yes, Meetily is a real-time application that captures microphone and system audio concurrently, processes speech through voice-activity detection, and streams transcription results to a React frontend instantly via Tauri events.

Meetily is an open-source AI meeting assistant developed by Zackriya-Solutions that operates as a low-latency, event-driven desktop application. Built with a Rust-powered Tauri backend and a Next.js/React frontend, Meetily processes audio continuously rather than in batches, enabling live transcription updates during active meetings.

How Real-Time Audio Capture Works

Meetily achieves real-time performance through concurrent audio stream processing implemented in the Rust core. The system captures audio from multiple sources simultaneously and immediately funnels raw PCM frames into an asynchronous processing pipeline.

Concurrent Microphone and System Audio Capture

The application reads from both microphone and system audio devices in parallel. In audio/capture/microphone.rs and audio/capture/system.rs, the capture modules feed raw AudioChunk structures into audio/pipeline.rs via async channels. This concurrent approach ensures that both participant speech and system audio are captured without synchronization delays.

Real-Time Mixing and Voice-Activity Detection

Once audio enters the pipeline, audio/pipeline.rs handles synchronization of mic and system buffers, applies RMS-based ducking to balance audio levels, and executes voice-activity detection (VAD) to filter silence before transcription. The VAD implementation in audio/vad.rs analyzes frames on-the-fly, ensuring that only speech-containing segments proceed to the transcription engine, reducing unnecessary processing and latency.

Real-Time Transcription Processing

The transcription layer operates as a streaming pipeline where speech chunks are processed immediately upon detection, not collected into minutes-long batches.

Chunk Dispatch and Worker Pool Architecture

Each speech-only chunk is dispatched instantly to a transcription worker pool via an UnboundedSender. In audio/transcription/worker.rs, the start_transcription_task function receives chunks from the channel and spawns parallel worker tasks. The following code demonstrates the real-time hand-off:

// Inside start_transcription_task
while let Some(chunk) = receiver.recv().await {
    let queued = chunks_queued.fetch_add(1, Ordering::SeqCst) + 1;
    log::info!("📥 Dispatching chunk {} (total queued: {})", chunk.chunk_id, queued);
    work_sender.send(chunk).unwrap(); // Real-time hand-off
}

Workers call the selected transcription engine—whether Whisper, Parakeet, or a custom provider—per chunk, producing partial or final results as soon as the model finishes inference.

Event Emission to Frontend

Upon completing transcription, workers emit Tauri events immediately. The transcribe_chunk_with_provider function in audio/transcription/worker.rs emits transcript-update events containing timestamps, confidence scores, and partial flags. When speech is first detected, it emits a speech-detected event:

let update = TranscriptUpdate {
    text: transcript,
    timestamp: format_current_timestamp(),
    source: "Audio".to_string(),
    sequence_id,
    chunk_start_time: chunk_timestamp,
    is_partial,
    confidence: confidence_opt.unwrap_or(0.85),
    audio_start_time,
    audio_end_time,
    duration: chunk_duration,
};

app.emit("transcript-update", &update)?;

Frontend Integration for Live Updates

The Next.js/React frontend consumes these events through Tauri's event system without requiring page reloads. In frontend/src/app/page.tsx and related components, listeners attach to the Rust backend and update UI state instantly.

Consuming Real-Time Transcript Events

The frontend invokes the recording command and immediately begins listening for updates:

// Start recording session
await invoke('start_recording_with_devices_and_meeting', {
  mic_device_name: "Built-in Mic",
  system_device_name: "BlackHole 2ch",
  meeting_name: "Team Sync"
});

// Listen for live transcript updates
await listen<TranscriptUpdate>('transcript-update', e => {
  setTranscripts(prev => [...prev, e.payload]); // UI updates instantly
});

// Optional: show speech-detected UI cue
await listen('speech-detected', () => setHasSpeech(true));

These listeners are wired up in frontend/src-tauri/src/lib.rs, which registers the Tauri commands and event handlers that bridge the Rust backend and TypeScript frontend.

Core Files Enabling Real-Time Operation

Several specific source files implement the low-latency architecture:

• frontend/src-tauri/src/lib.rs – Registers Tauri commands including start_recording_with_devices_and_meeting and coordinates the audio pipeline initialization.
• frontend/src-tauri/src/audio/pipeline.rs – Implements the mixing logic, VAD integration, and chunk production that feeds the transcription workers.
• frontend/src-tauri/src/audio/transcription/worker.rs – Manages parallel transcription workers, handles chunk processing, and emits transcript-update and speech-detected events via app.emit().
• frontend/src-tauri/src/audio/simple_level_monitor.rs – Streams real-time audio level meters for visual feedback during recording.
• frontend/src-tauri/src/audio/capture/microphone.rs and audio/capture/system.rs – Handle concurrent audio capture from hardware devices.
• frontend/src/app/page.tsx – Contains React hooks that invoke Tauri commands and consume real-time events to update the transcript view.

Summary

Meetily qualifies as a real-time application through the following architectural characteristics:

• Continuous audio capture from microphone and system sources via concurrent Rust streams
• On-the-fly processing including mixing, RMS-based ducking, and voice-activity detection in audio/pipeline.rs
• Immediate chunk dispatch to transcription workers using unbounded channels without batching delays
• Instant event emission via Tauri's app.emit() system, delivering partial and final transcripts to the frontend
• Live UI updates through React listeners that consume transcript-update events and render text without page reloads

Frequently Asked Questions

What makes Meetily real-time rather than batch-processing?

Meetily processes audio in chunks as small as a few seconds rather than waiting for recordings to complete. The audio/transcription/worker.rs file dispatches each speech segment to transcription engines immediately upon VAD detection, and the frontend receives updates via Tauri events within milliseconds of processing completion.

How does Meetily handle latency between audio capture and transcription display?

The architecture uses async channels and an UnboundedSender to move audio chunks from the capture pipeline to worker threads without blocking. The transcribe_chunk_with_provider function emits results immediately after inference, and the React frontend updates state synchronously upon receiving transcript-update events, typically achieving sub-second latency.

Can Meetily transcribe multiple audio sources simultaneously in real-time?

Yes. The system captures microphone and system audio concurrently through audio/capture/microphone.rs and audio/capture/system.rs, mixes them in audio/pipeline.rs, and processes the combined stream through a single real-time transcription pipeline, enabling live transcription of both local and remote meeting participants.

What technologies enable Meetily's real-time capabilities?

Meetily leverages Rust's async runtime for zero-cost concurrency in audio processing, Tauri's event system for low-latency frontend communication, and WebAssembly-compatible transcription engines (Whisper, Parakeet) that process chunks as they arrive rather than requiring complete audio files.

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