# Understanding the Project Structure of Meetily: A Complete Technical Guide

> Explore the Meetily project structure a hybrid desktop app. Learn about the Nextjs React frontend Rust Tauri backend and archived Python service. Complete technical guide.

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

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json) — Defines Node.js dependencies for React, Next.js, and Tauri API bindings
- [`frontend/next.config.js`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/next.config.js) — Configures the Next.js build process for the Tauri web view
- [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) — Main landing page that launches the recording interface
- [`frontend/src/components/Sidebar/SidebarProvider.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/components/Sidebar/SidebarProvider.tsx) — Global React context managing meeting state and recording actions
- [`frontend/src/components/DeviceSelection/DeviceSelection.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/clean_run.sh) and [`frontend/clean_build.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/main.rs) — Application entry point that registers Tauri commands and event listeners
- [`src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/recording_manager.rs)** — Coordinates high-level recording start/stop operations and state transitions
- **[`src/audio/recording_saver.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/recording_saver.rs)** — Writes mixed audio streams to WAV files on local disk
- **[`src/audio/vad.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/vad.rs)** — Implements voice-activity detection to filter non-speech audio before transcription
- **[`src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/summary/llm_client.rs)** — Abstracts API calls to Claude, Groq, OpenAI, and Ollama for meeting summarization
- **[`src/database/models.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/app/main.py) — Legacy FastAPI entry point
- `backend/whisper-custom/` — Custom C++ Whisper server implementation
- [`backend/docker-compose.yml`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md)** — High-level system diagrams showing the Tauri + Rust + React interaction
- **[`docs/BUILDING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs), which delegates to [`recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/recording_manager.rs) and [`pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/pipeline.rs), with VAD processing in [`src/audio/vad.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/vad.rs) and file output in [`src/audio/recording_saver.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/recording_saver.rs)
- **AI Integration**: Transcription runs through [`src/whisper_engine/whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/whisper_engine/whisper_engine.rs) while summarization uses [`src/summary/llm_client.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/main.rs) while command routing is defined in [`src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/SidebarProvider.tsx) and [`DeviceSelection.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/src/audio/recording_manager.rs), while the actual command interface exposed to the frontend is defined in [`src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.