How to Get Started with Meetily Development: Complete Setup Guide

To start Meetily development, clone the Zackriya-Solutions/meetily repository, install Node.js dependencies with PNPM, and run the ./clean_run.sh script to launch both the Next.js frontend and Rust Tauri backend in development mode.

Meetily is a privacy-first AI meeting assistant built as a single-page Tauri desktop application that processes all data locally. The project combines a Rust backend handling audio capture and AI inference with a Next.js/TypeScript frontend for the user interface. This guide covers the complete Meetily development workflow, from initial setup to understanding the core architecture and extending functionality.

Prerequisites and Repository Setup

Before diving into Meetily development, ensure your environment meets the baseline requirements. You will need Node.js ≥ 18 and the PNPM package manager for the frontend, plus Rust and Cargo for the Tauri backend.

Clone the repository and navigate to the project root:

git clone https://github.com/Zackriya-Solutions/meetily.git
cd meetily

Install the frontend dependencies:

cd frontend
pnpm install

Understanding the Meetily Architecture

Meetily follows a layered architecture that keeps sensitive meeting data on-device while leveraging local AI models. The application consists of six core layers:

Layer	Responsibility	Key Source File
Frontend (Next.js)	UI for meetings, transcripts, and settings; communicates via Tauri commands	frontend/src/app/page.tsx
Tauri Core (Rust)	Entry point and command registry managing window lifecycle	frontend/src-tauri/src/lib.rs
Audio Engine	Microphone/system audio capture, mixing, and voice activity detection (VAD)	frontend/src-tauri/src/audio/pipeline.rs
Transcription Engine	Whisper/Parakeet model wrapping with GPU support (Metal, CUDA, Vulkan)	frontend/src-tauri/src/whisper_engine/whisper_engine.rs
Database	Local SQLite storage for meetings and summaries	frontend/src-tauri/src/database/models.rs
Summary Engine	LLM provider orchestration (Ollama, Claude, Groq, OpenRouter)	frontend/src-tauri/src/summary/service.rs

The frontend and backend communicate through Tauri commands and events, ensuring type-safe IPC without network exposure.

Development Workflow

Launch the Development Environment

The repository includes helper scripts that streamline the Meetily development workflow. The clean_run.sh script clears build artifacts, starts the Next.js dev server on port 3118, and launches the Tauri desktop shell.

From the frontend directory, run:

# Standard development mode with info logging

./clean_run.sh

# Or enable detailed debug logs

./clean_run.sh debug

This executes pnpm run dev for the Next.js server and pnpm run tauri:dev to compile and run the Rust core with hot-reloading enabled.

Verify Command Interaction

Test the IPC bridge by invoking a Rust command from the frontend. The following TypeScript snippet from frontend/src/app/page.tsx demonstrates starting a recording session:

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

await invoke('start_recording', {
  mic_device_name: "Built-in Microphone",
  system_device_name: "BlackHole 2ch",
  meeting_name: "Team Standup"
});

The corresponding Rust implementation resides in frontend/src-tauri/src/audio/recording_commands.rs, which delegates to audio/recording_manager.rs to manage the audio pipeline state.

Working with the Codebase

Adding New Tauri Commands

Extending Meetily requires registering new commands in the Tauri handler. To add a command, modify frontend/src-tauri/src/lib.rs:

#[tauri::command]
async fn echo_message(msg: String) -> Result<String, String> {
    Ok(format!("Echo: {}", msg))
}

tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![
        start_recording,
        echo_message, // Register new command here
    ])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");

After adding the command, invoke it from the frontend using the invoke function with the exact command name.

Listening to Rust-Emitted Events

The audio pipeline emits real-time updates via Tauri's event system. Subscribe to these in your React components:

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

listen<{ text: string }>('transcript-update', (event) => {
  console.log('New transcript chunk:', event.payload.text);
});

The Rust side emits this event from frontend/src-tauri/src/audio/recording_manager.rs using app.emit("transcript-update", ...), enabling live transcript updates in the UI.

Configuring GPU Acceleration

Meetily supports hardware-accelerated transcription via Metal on macOS, CUDA on Windows, and Vulkan on Linux. Enable these features through Cargo flags when building:

# macOS Metal (auto-detected, no flag needed)

cargo tauri dev

# Windows with NVIDIA GPU

cargo tauri dev --features cuda

# Linux with Vulkan support

cargo tauri dev --features vulkan

Configure the transcription model at runtime by calling:

await invoke('load_whisper_model', { model_name: "base" });

The Rust implementation in frontend/src-tauri/src/whisper_engine/whisper_engine.rs handles model loading and caches the instance for subsequent transcriptions.

Running Tests

Validate your changes without launching the full application. The repository includes unit tests for audio processing and database modules:

cargo test --workspace

This command executes all Rust tests across the workspace, ensuring the audio pipeline and database models function correctly before integration.

Key Files for New Contributors

Navigate these critical files when exploring the Meetily development environment:

• README.md – Project overview and high-level installation steps
• docs/architecture.md – System-level architecture diagrams
• frontend/src-tauri/src/lib.rs – Tauri entry point and command registration
• frontend/src-tauri/src/audio/mod.rs – Public audio module exports
• frontend/src-tauri/src/audio/pipeline.rs – Audio mixing and VAD logic
• frontend/src-tauri/src/audio/recording_manager.rs – Recording orchestration
• frontend/src-tauri/src/whisper_engine/whisper_engine.rs – Model inference
• frontend/src-tauri/src/summary/service.rs – LLM summarization logic
• frontend/src/app/page.tsx – Example UI implementing recording controls
• frontend/clean_run.sh – Development launch script
• frontend/src-tauri/Cargo.toml – GPU feature configuration
• frontend/src-tauri/src/database/models.rs – SQLite schema definitions

Summary

• Meetily development requires Node.js ≥ 18, PNPM, and Rust installed locally before cloning the Zackriya-Solutions/meetily repository.
• The ./clean_run.sh script automates launching the Next.js dev server and Tauri backend simultaneously for rapid iteration.
• Architecture consists of a Rust backend (audio, transcription, database) and Next.js frontend communicating via Tauri commands.
• Extend functionality by registering commands in lib.rs and handling events for real-time updates like transcripts.
• Enable GPU acceleration via --features cuda or --features vulkan flags during compilation.
• Run cargo test --workspace to validate audio and database logic before submitting changes.

Frequently Asked Questions

What hardware requirements are needed for Meetily development?

Meetily development requires a system capable of running Rust and Node.js simultaneously. For GPU-accelerated transcription, you need a compatible graphics card: Apple Silicon or AMD for Metal on macOS, NVIDIA for CUDA on Windows, or Vulkan-compatible hardware on Linux. The SQLite database and audio processing work on any modern CPU without specialized hardware.

How does the frontend communicate with the Rust backend?

The frontend invokes Rust functions through Tauri commands using the invoke API, as seen in frontend/src/app/page.tsx when calling start_recording. For asynchronous updates like transcription chunks, Rust emits events via app.emit() that the frontend captures using the listen function from @tauri-apps/api/event, creating a reactive data flow without polling.

Can I use a different package manager instead of PNPM?

While PNPM is recommended and used in the official clean_run.sh scripts, you can use NPM or Yarn by replacing pnpm install with your preferred install command and adjusting the scripts in frontend/package.json. Ensure you update the clean_run.sh script accordingly to invoke the correct package manager when launching the development environment.

Where are the AI models stored during development?

The transcription engine caches Whisper models locally after first download, managed by the code in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. Models are loaded into memory via the load_whisper_model command and persist across application restarts, avoiding redundant downloads. The specific storage location depends on the Tauri app data directory configuration in your operating system.

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