# Meetily Core Features Explained: AI-Powered Offline Meeting Assistant

> Explore Meetily's core features: AI-powered offline meeting assistant for real-time transcription, GPU-accelerated summaries, and audio recording. All processed locally for ultimate privacy.

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

---

**Meetily is a privacy-first, self-contained desktop application that delivers real-time transcription, GPU-accelerated AI summaries, and professional audio recording entirely on your local machine—no cloud required.**

Built by [Zackriya Solutions](https://github.com/Zackriya-Solutions), meetily combines a Rust-powered Tauri backend with a Next.js frontend to process meeting audio, generate transcripts with Whisper/Parakeet, and produce AI summaries through local or custom LLM endpoints. Every feature runs on-device, ensuring sensitive meeting data never leaves your computer.

---

## Local-First Real-Time Transcription

Meetily's **local-first transcription** captures both microphone and system audio, applies Voice Activity Detection (VAD), and feeds speech chunks directly to on-device Whisper or Parakeet models.

The audio pipeline lives in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs). This module handles:

- **Dual-source capture**: Simultaneous recording from microphone and system audio
- **VAD processing**: Filters silence to reduce unnecessary transcription load
- **Buffer management**: Streams audio chunks to the inference engine

The actual transcription engine resides 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). It loads models, manages GPU kernels, and returns timestamped text segments.

---

## AI-Powered Meeting Summaries

Once a transcript is complete, Meetily sends it to a locally-hosted LLM (default: **Ollama**) or any OpenAI-compatible endpoint to generate structured meeting minutes.

The summary generation flow:

1. Transcript is collected from the recording session
2. A formatted prompt is constructed with meeting context
3. The LLM provider is called via HTTP with configurable parameters
4. The response is parsed and returned to the UI

The orchestration happens 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 `generate_summary`. Configuration parsing for custom endpoints is handled in [`frontend/src-tauri/src/config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/config.rs).

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

const summary = await invoke<string>('generate_summary', {
  meeting_id: '2024-07-08-standup',
  provider: 'ollama',      // or 'openai', 'groq', 'custom'
  model: 'llama3.1',
});

```

---

## Professional Audio Mixing

Meetily includes a **professional audio mixer** that balances mic and system recordings in real time. 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**: Automatically reduces system audio when microphone input is detected
- **Clipping prevention**: Hard limiters protect against digital distortion
- **Synchronized mixing**: Outputs a single clean stereo file with properly aligned sources

This eliminates the common problem of one audio source drowning out the other in hybrid meeting recordings.

---

## GPU Acceleration for Inference

Meetily automatically detects and utilizes available GPU hardware for faster transcription. The build system supports three backends via Cargo feature flags:

| Platform | Backend | Build Command |
|----------|---------|---------------|
| macOS (Apple Silicon/Intel) | Metal | `cargo build --release --features metal` |
| Windows | CUDA | `cargo build --release --features cuda` |
| Linux | Vulkan | `cargo build --release --features vulkan` |

Feature flags are declared in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml). At runtime, [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) selects the optimal backend based on availability and model requirements. Hardware-specific documentation is available in [`docs/GPU_ACCELERATION.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/GPU_ACCELERATION.md).

---

## Cross-Platform Audio Device Support

Meetily runs natively on **macOS**, **Windows**, and **Linux** with platform-specific device enumeration modules:

- [`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)
- [`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)
- [`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)

These modules discover available input and loopback devices, presenting them in the React frontend at [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) for user selection.

---

## Custom OpenAI-Compatible Endpoints

Enterprises and privacy-conscious users can redirect summary generation to self-hosted or third-party API endpoints. The configuration structure in [`frontend/src-tauri/src/config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/config.rs) exposes:

```rust
pub struct LlmConfig {
    pub endpoint: String,   // e.g., "https://api.internal.company.com/v1/chat/completions"
    pub api_key: String,
    pub model: String,
}

```

This enables deployment scenarios where Ollama is hosted on internal infrastructure or where commercial providers (Groq, OpenAI, Azure) are preferred.

---

## Import and Enhance Workflow

Meetily supports **post-hoc processing** of existing audio files through the import workflow:

1. Users select an audio file through the React UI ([`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx))
2. The file is routed through [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs)
3. Transcription runs with selectable model and language parameters
4. Generated summaries can use different LLM configurations than live meetings

This allows teams to backfill meeting archives or re-process recordings with improved models.

---

## Extensible Tauri Command API

The frontend-backend bridge is implemented through Tauri's command system. All core operations are exposed as async Rust functions in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs):

```rust
tauri::generate_handler![
    start_recording,
    stop_recording,
    generate_summary,
    // ... additional commands
]

```

Frontend TypeScript invokes these directly:

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

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

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

// Stop and finalize
await invoke('stop_recording');

```

---

## Summary

- **Meetily** processes all meeting data locally using a Tauri 2 architecture (Rust backend, Next.js frontend)
- **Real-time transcription** runs Whisper/Parakeet models with VAD and dual-source audio capture
- **AI summaries** integrate with Ollama, OpenAI, Groq, or any compatible endpoint via configurable `LlmConfig`
- **GPU acceleration** supports Metal, CUDA, and Vulkan through compile-time feature flags
- **Professional audio mixing** applies RMS ducking and clipping prevention in [`pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/pipeline.rs)
- **Cross-platform support** covers macOS, Windows, and Linux with dedicated device enumeration modules
- **Import workflow** enables re-transcription and enhanced processing of existing audio files

---

## Frequently Asked Questions

### Does Meetily send any meeting data to the cloud?

No. By default, Meetily operates entirely offline according to the [architecture documentation](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md). Audio capture, transcription with Whisper/Parakeet, and summary generation through Ollama all run on your local machine. You may optionally configure a cloud LLM endpoint, but this is not required.

### What hardware is required for GPU acceleration?

Meetily supports Apple Silicon and Intel Macs via **Metal**, NVIDIA GPUs on Windows via **CUDA**, and Vulkan-compatible hardware on Linux. GPU detection and kernel selection happen automatically at runtime 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). CPU-only operation is available as a fallback.

### Can I use Meetily with my company's internal LLM?

Yes. The `LlmConfig` struct in [`frontend/src-tauri/src/config.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/config.rs) accepts any OpenAI-compatible endpoint URL. Set your internal API address and authentication key through the configuration interface, and the summary command will route requests accordingly.

### How does Meetily handle audio from video calls?

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) captures system audio (including video call participants) through loopback devices while simultaneously recording your microphone. RMS-based ducking ensures your voice remains intelligible when others speak, producing a balanced single-track recording.