# How to Get Started with Meetily Development: Complete Setup Guide

> Start Meetily development setting up the frontend and backend. Clone the repository, install Node.js dependencies with PNPM, and run the clean_run.sh script to launch your app.

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

---

**To start Meetily development, clone the Zackriya-Solutions/meetily repository, install Node.js dependencies with PNPM, and run the [`./clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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:

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

```

Install the frontend dependencies:

```bash
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) |
| **Tauri Core (Rust)** | Entry point and command registry managing window lifecycle | [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs) |
| **Database** | Local SQLite storage for meetings and summaries | [`frontend/src-tauri/src/database/models.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/database/models.rs) |
| **Summary Engine** | LLM provider orchestration (Ollama, Claude, Groq, OpenRouter) | [`frontend/src-tauri/src/summary/service.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```bash

# 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) demonstrates starting a recording session:

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs), which delegates to [`audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs):

```rust
#[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:

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```bash

# 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:

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

```

The Rust implementation 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) 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:

```bash
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/README.md) – Project overview and high-level installation steps
- [`docs/architecture.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md) – System-level architecture diagrams
- [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) – Tauri entry point and command registration
- [`frontend/src-tauri/src/audio/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/mod.rs) – Public audio module exports
- [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) – Audio mixing and VAD logic
- [`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_manager.rs) – Recording orchestration
- [`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) – Model inference
- [`frontend/src-tauri/src/summary/service.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/service.rs) – LLM summarization logic
- [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) – Example UI implementing recording controls
- [`frontend/clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/clean_run.sh) – Development launch script
- [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml) – GPU feature configuration
- [`frontend/src-tauri/src/database/models.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json). Ensure you update the [`clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.