# Core Features of Meetily: A Privacy-First AI Meeting Assistant

> Discover Meetily's core features: local AI meeting transcription, summaries, and audio processing. Your data stays completely private on your machine. Experience secure, efficient meetings today.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: deep-dive
- Published: 2026-07-08

---

**Meetily is a self-contained desktop application built with Tauri 2 that delivers real-time transcription, AI-powered meeting summaries, and professional audio processing entirely on your local machine, ensuring no meeting data ever leaves your computer.**

The Zackriya-Solutions/meetily repository provides a complete, open-source meeting assistant that combines a Rust backend with a Next.js frontend. By leveraging local Whisper models and OpenAI-compatible LLMs, Meetily eliminates cloud dependencies while providing enterprise-grade audio processing capabilities.

## Local-First Real-Time Transcription

Meetily captures both microphone and system audio simultaneously, processes it through Voice Activity Detection (VAD), and streams speech chunks to local Whisper or Parakeet models for instant transcription.

The audio pipeline in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) handles the complex task of mixing multiple audio sources while applying real-time buffering. When speech is detected, the system passes audio segments to [`frontend/src-tauri/src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs), which manages model loading and inference without requiring internet connectivity.

## AI-Powered Meeting Summaries

Once transcription completes, Meetily generates concise meeting minutes by sending the transcript to a locally-hosted LLM via Ollama or any OpenAI-compatible endpoint.

The summarization logic resides in [`frontend/src-tauri/src/commands/summary.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/commands/summary.rs), registered as a Tauri command in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs). This architecture allows users to process sensitive meeting content without transmitting data to external APIs, though the system supports external endpoints when desired.

## Professional Audio Mixing

The application includes sophisticated audio processing through the `ProfessionalAudioMixer` implementation in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs). This system simultaneously records microphone and system audio while applying RMS-based ducking and clipping prevention to produce balanced, broadcast-quality recordings.

Audio device management is platform-specific, with separate implementations for macOS ([`macos.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/macos.rs)), Windows ([`windows.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/windows.rs)), and Linux ([`linux.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/linux.rs)) under `frontend/src-tauri/src/audio/devices/platform/`.

## GPU Acceleration Support

Meetily automatically detects available GPU backends and loads optimized inference kernels for transcription. The system supports Metal on macOS (Apple Silicon and Intel), CUDA on Windows and Linux, and Vulkan on Linux systems.

Feature flags in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) control backend compilation:

```bash

# macOS – Metal (Apple Silicon)

cargo build --release --features metal

# Windows – CUDA

cargo build --release --features cuda

# Linux – Vulkan

cargo build --release --features vulkan

```

The Whisper engine in [`frontend/src-tauri/src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs) selects the appropriate backend at runtime based on available hardware.

## Cross-Platform Audio Device Management

The application provides native audio device enumeration across all supported platforms. Platform-specific modules in `frontend/src-tauri/src/audio/devices/platform/` handle device discovery and selection, allowing users to choose specific input and output devices for recording.

The React frontend in [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) presents these devices through a unified interface, enabling users to configure complex routing scenarios like capturing system audio through virtual cables alongside physical microphones.

## Custom OpenAI-Compatible Endpoints

For enterprise deployments, Meetily supports custom LLM endpoints beyond local Ollama instances. Configuration parsing in [`frontend/src-tauri/src/config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/config.rs) defines the `LlmConfig` struct:

```rust
pub struct LlmConfig {
    pub endpoint: String,
    pub api_key: String,
    pub model: String,
}

```

The summary command uses this configuration to send authenticated requests to self-hosted or corporate LLM endpoints, enabling flexible deployment scenarios while maintaining the application's local-first architecture.

## Working with Meetily's API

### Starting and Stopping Recordings

Frontend applications interact with the Rust backend through Tauri commands:

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

// Start a new meeting recording
await invoke('start_recording', {
  mic_device_name: 'Built-in Microphone',
  system_device_name: 'BlackHole 2ch',
  meeting_name: 'Team Stand-up',
});

// Listen for live transcript updates
await listen<{ text: string }>('transcript-update', (e) => {
  console.log('Live transcript:', e.payload.text);
});

// When the meeting ends
await invoke('stop_recording');

```

These commands are defined in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) using the `#[tauri::command]` macro and exported through `tauri::generate_handler!`.

### Generating Meeting Summaries

Trigger summary generation with specific model selection:

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

const summary = await invoke<string>('generate_summary', {
  meeting_id: '2024-07-08-standup',
  provider: 'ollama',          // can also be 'openai', 'groq', etc.
  model: 'llama3.1',           // the model name on the selected provider
});

console.log('Meeting summary:', summary);

```

### Import and Enhancement Workflow

Meetily supports importing existing audio files for re-transcription with different models or languages. This workflow is implemented in the frontend at [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) and backed by [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs), allowing users to process historical recordings or experiment with different Whisper model sizes.

## Summary

Meetily delivers a comprehensive set of core features designed for privacy-conscious users and organizations:

- **Local transcription** using Whisper/Parakeet models with no cloud dependencies, implemented in [`frontend/src-tauri/src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs)
- **AI summarization** through configurable LLM endpoints (local Ollama or custom OpenAI-compatible APIs) in [`frontend/src-tauri/src/commands/summary.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/commands/summary.rs)
- **Professional audio mixing** with VAD, ducking, and clipping prevention via `ProfessionalAudioMixer` in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs)
- **GPU acceleration** with automatic backend detection for Metal, CUDA, and Vulkan through Cargo feature flags
- **Cross-platform support** with native audio device handling for macOS, Windows, and Linux
- **Extensible architecture** built on Tauri 2, exposing Rust commands to a Next.js frontend via [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs)

## Frequently Asked Questions

### Does Meetily require an internet connection to transcribe meetings?

No. Meetily performs all transcription locally using Whisper or Parakeet models loaded into [`frontend/src-tauri/src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs). The application only requires internet connectivity if you choose to use cloud-based LLM endpoints for summarization, though local Ollama integration works completely offline.

### How does Meetily handle audio quality when recording both microphone and system audio?

The `ProfessionalAudioMixer` in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) applies RMS-based ducking and clipping prevention algorithms to balance multiple audio sources. This ensures that system audio and microphone input maintain consistent levels without distortion, producing professional-quality recordings suitable for transcription.

### Can Meetily run on Apple Silicon Macs with GPU acceleration?

Yes. Meetily fully supports Apple Silicon through Metal acceleration. Build the application with `cargo build --release --features metal` to enable GPU-accelerated transcription. The detection logic in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) and the engine code automatically utilize the Neural Engine and GPU cores on M1/M2/M3 chips.

### Is it possible to use Meetily with my company's internal LLM endpoint?

Absolutely. Configuration in [`frontend/src-tauri/src/config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/config.rs) allows you to specify custom endpoints, API keys, and model names. The summary command in [`frontend/src-tauri/src/commands/summary.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/commands/summary.rs) sends standard OpenAI-compatible requests, making it compatible with self-hosted solutions like vLLM, text-generation-inference, or corporate OpenAI proxies.