What Frameworks Does Meetily Utilize? Complete Tech Stack Breakdown

Meetily utilizes Tauri 2.x for its desktop shell, Next.js 14 with React 18 for the user interface, Rust with specialized crates like cpal and whisper-rs for audio processing, and SQLite for local data persistence.

Meetily is a privacy-first desktop AI meeting assistant developed by Zackriya-Solutions that processes all meeting data locally on the user's machine. The application's architecture combines modern web technologies with high-performance native components to deliver real-time transcription without cloud dependencies. Understanding what frameworks Meetily utilizes reveals how the project achieves native desktop performance while maintaining a flexible, React-based interface.

Desktop Foundation: Tauri 2.x and Rust

Meetily runs as a cross-platform desktop application using Tauri 2.x, a Rust-based framework that replaces heavier alternatives like Electron. Tauri provides the native window shell, manages system-level permissions, and handles Inter-Process Communication (IPC) between the frontend and backend.

The Tauri configuration resides in frontend/src-tauri/tauri.conf.json, which defines the application window properties, security policies, and allowed native capabilities. Rust serves as the backbone for performance-critical operations, including audio capture and AI model inference, ensuring minimal resource usage compared to traditional Node.js-based desktop apps.

Frontend Architecture: Next.js 14 and React 18

The user interface layer relies on Next.js 14 and React 18 to render the application shell within Tauri's webview. This setup provides modern React features like concurrent rendering and server-side rendering capabilities while maintaining a single-page application feel suitable for desktop software.

The main entry point sits at frontend/src/app/page.tsx, which orchestrates the recording interface and communicates with Rust commands through Tauri's API bridge.

Styling and Component System

Tailwind CSS powers the responsive design system, configured in frontend/tailwind.config.ts with custom theme extensions for the desktop environment. Radix UI primitives provide accessible base components (dialogs, dropdowns, sliders) that are wrapped into custom shadcn-style components within frontend/src/components/ui/*. This combination ensures keyboard navigation and screen-reader compatibility without sacrificing visual customization.

State Management

Rather than heavy external state libraries, Meetily uses React Context combined with custom hooks (prefixed use*) to share recording status, transcript streams, and configuration settings across the component tree. The frontend/src/contexts/RecordingStateContext.tsx file defines the primary context for tracking active recordings and microphone input levels.

Audio Processing Pipeline: Rust Crates

The audio engine represents Meetily's most complex subsystem, leveraging three specialized Rust crates to handle capture, voice detection, and transcription entirely on-device.

Audio Capture with cpal

Low-level microphone and system audio input uses cpal (Cross-Platform Audio Library), a Rust crate providing direct access to host audio APIs (CoreAudio on macOS, WASAPI on Windows, ALSA/PipeWire on Linux). The implementation in frontend/src-tauri/src/audio/capture/microphone.rs handles device enumeration, sample rate negotiation, and real-time audio buffer streaming.

Speech-to-Text with whisper-rs

Transcription relies on whisper-rs, Rust bindings for Whisper.cpp that run OpenAI's Whisper models locally without network calls. The engine initialization and inference logic live in frontend/src-tauri/src/whisper_engine/whisper_engine.rs, where audio chunks are converted to mel spectrograms and processed through the neural network.

Voice Activity Detection with Parakeet

To optimize resources and filter non-speech audio, Meetily integrates Parakeet, a Rust implementation of Voice Activity Detection (VAD). Located in frontend/src-tauri/src/lib/parakeet.rs, this module analyzes audio frames in real-time, ensuring only speech segments are forwarded to the Whisper engine for expensive transcription operations.

Local Data Persistence: SQLite via rusqlite

All meeting transcripts, metadata, and user settings store locally using SQLite accessed through the rusqlite crate. Unlike cloud-dependent solutions, this approach guarantees data privacy by keeping information in a single local database file.

The database abstraction layer in frontend/src-tauri/src/database/mod.rs manages schema migrations, connection pooling, and CRUD operations for meetings and transcripts. This module ensures atomic writes during active recordings to prevent data corruption if the application crashes.

AI Integration Layer

For generating meeting summaries and action items, Meetily interfaces with multiple Large Language Model (LLM) providers through HTTP clients implemented in Rust. The system supports Ollama for completely local inference, as well as cloud alternatives like Claude, Groq, and OpenRouter when users opt for external processing.

These integrations reside in frontend/src-tauri/src/lib/builtin‑ai.rs, which normalizes API request formats across different providers while maintaining the privacy-first default of local Ollama instances.

Code Examples

Invoking Tauri Commands from React

The frontend initiates recordings by calling Rust functions through Tauri's command bridge:

// frontend/src/app/page.tsx – start a new recording
await invoke('start_recording', {
  mic_device_name: 'Built‑in Microphone',
  system_device_name: 'BlackHole 2ch',
  meeting_name: 'Team Stand‑up',
});

The corresponding handler in frontend/src-tauri/src/lib.rs validates parameters and spawns the audio capture thread.

Listening to Real-time Transcription Events

React components subscribe to transcription updates emitted from the Rust backend:

// frontend/src/app/page.tsx – listen for transcript updates
useEffect(() => {
  const unlisten = await listen<TranscriptUpdate>('transcript-update', e => {
    setTranscripts(prev => [...prev, e.payload]);
  });
  return () => unlisten();
}, []);

This pattern streams partial transcription results to the UI without polling.

Processing Audio in Rust

The Whisper engine processes audio chunks asynchronously and emits results to the frontend:

// frontend/src-tauri/src/whisper_engine/whisper_engine.rs
let result = self.engine.transcribe(audio_chunk).await?;
app.emit("transcript-update", TranscriptUpdate {
    text: result.text,
    timestamp: Utc::now(),
})?;

Database Operations

Meeting metadata persists to SQLite through rusqlite:

// frontend/src-tauri/src/database/mod.rs
let conn = Connection::open("meetings.db")?;
conn.execute(
    "INSERT INTO meetings (name, created_at) VALUES (?1, datetime('now'))",
    params![meeting_name],
)?;

Build System and Package Management

Meetily uses a dual-package management approach:

• Cargo manages Rust dependencies (Tauri, cpal, whisper-rs, rusqlite) defined in frontend/src-tauri/Cargo.toml
• pnpm handles Node.js dependencies (Next.js, React, Tailwind, Radix) defined in frontend/package.json

This separation allows each layer to use its ecosystem's optimized tools while the Tauri CLI coordinates cross-compilation and bundling into platform-specific installers.

Summary

• Tauri 2.x provides the lightweight Rust-based desktop container, replacing Electron for better performance.
• Next.js 14 and React 18 render the modern web-based user interface within the native shell.
• Tailwind CSS and Radix UI create an accessible, responsive design system tailored for desktop use.
• Rust crates (cpal, whisper-rs, parakeet) handle real-time audio capture, voice detection, and on-device transcription.
• SQLite via rusqlite ensures all meeting data remains local and private.
• Ollama/LLM integrations generate insights without mandatory cloud dependencies.

Frequently Asked Questions

Is Meetily built with Electron?

No, Meetily uses Tauri 2.x instead of Electron. Tauri leverages the operating system's native webview and a Rust backend, resulting in significantly smaller bundle sizes and lower memory usage compared to Electron's bundled Chromium approach.

Why does Meetily use Rust for audio processing instead of JavaScript?

Rust provides deterministic memory management and zero-cost abstractions essential for real-time audio processing. The cpal and whisper-rs crates require direct system resource management that JavaScript's garbage collection cannot reliably provide without audio dropouts or latency issues.

What database does Meetily use to store meeting transcripts?

Meetily uses SQLite accessed through the rusqlite Rust crate. All data stores locally in a single file on the user's machine, ensuring complete privacy and offline functionality without external database servers.

Can Meetily work with local LLMs without internet access?

Yes, Meetily supports Ollama for local LLM inference, allowing summary generation and insight extraction without sending data to external servers. The system also supports remote providers like Claude and Groq when users choose to enable them in frontend/src-tauri/src/lib/builtin‑ai.rs.

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