Understanding the Project Structure of Meetily: A Complete Technical Guide

TLDR: Meetily organizes its codebase as a hybrid desktop application with a Next.js/React frontend in frontend/ and a Rust-based Tauri backend in frontend/src-tauri/, alongside an archived Python service in backend/ and project documentation in docs/.

Meetily is a privacy-first AI meeting assistant built as a single, self-contained desktop application by Zackriya-Solutions. The repository follows a clear separation between the user interface layer and the native audio processing engine, allowing developers to navigate the codebase efficiently whether they are modifying UI components or optimizing the real-time audio pipeline.

Top-Level Directory Layout

The repository is organized around four primary areas that define the application's architecture:

• frontend/ — Contains the Next.js web assets, React components, and the Tauri Rust backend source code
• backend/ — Archived Python/FastAPI legacy code (not required for current builds)
• docs/ — Architecture diagrams, build guides, and GPU acceleration notes
• .github/ — CI/CD workflows and GitHub Actions configurations

The critical architectural detail is that frontend/src-tauri/ houses all native Rust code powering Meetily's audio engine, database, and AI integration, while the parent frontend/ directory manages the JavaScript/TypeScript web view.

Frontend Architecture

The frontend splits cleanly between the web-based UI and the native Tauri backend that provides system-level access to audio hardware.

UI Layer (Next.js)

The React-based interface resides in the frontend/ directory and handles all user interactions, state management, and device selection.

Key files include:

• frontend/package.json — Defines Node.js dependencies for React, Next.js, and Tauri API bindings
• frontend/next.config.js — Configures the Next.js build process for the Tauri web view
• frontend/src/app/page.tsx — Main landing page that launches the recording interface
• frontend/src/components/Sidebar/SidebarProvider.tsx — Global React context managing meeting state and recording actions
• frontend/src/components/DeviceSelection/DeviceSelection.tsx — UI component for selecting microphone and system audio devices

Build automation is handled by shell scripts like frontend/clean_run.sh and frontend/clean_build.sh, which manage the clean-build-run cycle for local development.

Tauri Backend (Rust)

The frontend/src-tauri/ directory contains the Rust codebase that compiles to native code and exposes commands to the JavaScript frontend.

Entry points and command definitions:

• src/main.rs — Application entry point that registers Tauri commands and event listeners
• src/lib.rs — High-level command definitions mapping frontend invoke calls to Rust functions like start_recording and stop_recording

Audio Pipeline and AI Engine

The Rust backend is organized into specialized modules handling audio processing, transcription, and AI summarization.

Audio Processing Stack

The core audio functionality lives in src/audio/ and src/audio_v2/:

• src/audio/pipeline.rs — Orchestrates microphone and system audio stream capture, applies VAD filtering, and manages professional-grade audio mixing
• src/audio/recording_manager.rs — Coordinates high-level recording start/stop operations and state transitions
• src/audio/recording_saver.rs — Writes mixed audio streams to WAV files on local disk
• src/audio/vad.rs — Implements voice-activity detection to filter non-speech audio before transcription
• src/audio/recording_commands.rs — Exposes recording controls to the frontend via Tauri commands

AI and Transcription Modules

Specialized engines handle speech-to-text and LLM integration:

• src/whisper_engine/whisper_engine.rs — Loads GGML Whisper models, manages GPU acceleration detection, and runs inference
• src/parakeet_engine/ — Alternative Parakeet model support for transcription
• src/summary/llm_client.rs — Abstracts API calls to Claude, Groq, OpenAI, and Ollama for meeting summarization
• src/database/models.rs — SQLite schema definitions for meetings, transcripts, summaries, and application settings

Legacy Backend (Archived)

The backend/ directory contains a legacy Python/FastAPI service that previously exposed REST APIs for transcription and summarization. This code is now archived and not required for the current Tauri-only application.

Historical components include:

• backend/app/main.py — Legacy FastAPI entry point
• backend/whisper-custom/ — Custom C++ Whisper server implementation
• backend/docker-compose.yml — Docker configuration for the deprecated service

You can safely ignore this directory when building or extending Meetily.

Documentation and Build Infrastructure

Supporting files ensure reproducible builds and comprehensive documentation:

• docs/architecture.md — High-level system diagrams showing the Tauri + Rust + React interaction
• docs/BUILDING.md — Platform-specific instructions for macOS, Windows, and Linux compilation
• .github/workflows/ — Automated CI pipelines for testing and multi-platform release builds
• scripts/ — Utility scripts including test-update-locally.js for development testing

Key Developer Workflows

When extending Meetily, you will typically interact with the frontend through Tauri commands. Below is the TypeScript pattern used in the UI to initiate recording:

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

async function startMeetingRecording(meetingName: string) {
  const micDevice = 'Built-in Microphone';
  const systemDevice = 'BlackHole 2ch';

  try {
    await invoke('start_recording', {
      mic_device_name: micDevice,
      system_device_name: systemDevice,
      meeting_name: meetingName,
    });
    console.log('Recording started');
  } catch (e) {
    console.error('Failed to start recording:', e);
  }
}

This invokes the native implementation in frontend/src-tauri/src/audio/recording_commands.rs, which delegates to recording_manager.rs and pipeline.rs.

Summary

• Hybrid Architecture: Meetily combines a Next.js frontend (frontend/) with a Rust Tauri backend (frontend/src-tauri/) for native audio access
• Audio Pipeline: Core recording logic resides in src/audio/pipeline.rs, with VAD processing in src/audio/vad.rs and file output in src/audio/recording_saver.rs
• AI Integration: Transcription runs through src/whisper_engine/whisper_engine.rs while summarization uses src/summary/llm_client.rs supporting multiple LLM providers
• Legacy Code: The backend/ directory contains archived Python code not required for current operation
• Entry Points: Application bootstrapping occurs in src/main.rs while command routing is defined in src/lib.rs

Frequently Asked Questions

What is the difference between the frontend and src-tauri directories?

The frontend/ directory contains the web-based user interface built with Next.js and React, including components like SidebarProvider.tsx and DeviceSelection.tsx. The frontend/src-tauri/ directory contains the Rust backend that compiles to native code and handles system-level operations like audio capture, transcription, and database access through Tauri commands.

Is the Python backend required to run Meetily?

No. The backend/ directory contains an archived Python/FastAPI service that is no longer used. The current application is entirely self-contained within the frontend/ directory using the Rust Tauri backend for all audio processing and AI functionality.

Where is the audio processing logic located?

The core audio pipeline is implemented in Rust within frontend/src-tauri/src/audio/pipeline.rs, which coordinates microphone capture, system audio mixing, and voice-activity detection. High-level recording state management is handled by src/audio/recording_manager.rs, while the actual command interface exposed to the frontend is defined in src/audio/recording_commands.rs.

How do React components communicate with the Rust backend?

React components use Tauri's invoke function imported from @tauri-apps/api/tauri to call Rust commands defined in frontend/src-tauri/src/lib.rs. For example, the frontend calls invoke('start_recording', {...}) which maps to the corresponding Rust function, allowing seamless communication between the TypeScript UI and native audio processing code.

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