How to Contribute to the Meetily Project: A Complete Developer's Guide

Contributing to Meetily requires forking the repository, branching from devtest (not main), and submitting pull requests that include tests and follow conventional commit standards for changes to the Rust backend or Next.js frontend.

Meetily is a privacy-first AI meeting assistant built as a Tauri desktop application that tightly couples a Rust backend with a Next.js/React frontend. Before writing code, understanding the repository structure and development workflow ensures your contributions align with the project's architecture and quality standards.

Understanding Meetily's Architecture

Meetily organizes its codebase into distinct layers that handle audio capture, transcription, and AI-powered summarization. The frontend in frontend/src/app/page.tsx communicates with the Rust backend through Tauri commands and events.

Component	Role	Key Source File
Frontend (Next.js)	UI for meeting management, transcript display, and settings	frontend/src/app/page.tsx
Tauri Core (Rust)	Window handling, command registration, and event dispatch	frontend/src-tauri/src/lib.rs
Audio Engine	Microphone and system audio capture, professional mixing, and voice activity detection (VAD)	frontend/src-tauri/src/audio/pipeline.rs
Transcription Engine	Local Whisper/Parakeet execution with GPU acceleration	frontend/src-tauri/src/whisper_engine/whisper_engine.rs
Database	SQLite storage for meetings, transcripts, and summaries	frontend/src-tauri/src/database/models.rs
Summary Engine	LLM provider integration (Ollama, Claude, Groq, OpenRouter)	frontend/src-tauri/src/summary/processor.rs

For a visual overview, reference docs/architecture.md before modifying any core systems.

Setting Up Your Development Environment

Start by forking the repository on GitHub and cloning your fork locally. The project uses a monorepo structure with the frontend and Rust backend colocated.

git clone https://github.com/YOUR_USERNAME/meetily.git
cd meetily

Install dependencies for both the frontend and Tauri backend according to the setup instructions in CONTRIBUTING.md. Ensure you have Rust, Node.js, and any system dependencies for Tauri development installed before proceeding.

Contribution Workflow for Meetily

Meetily follows a structured workflow defined in CONTRIBUTING.md (lines 7-94). All contributions must target the devtest branch, not main.

Branch Strategy

Always branch from devtest and pull the latest changes before creating your feature branch.

git checkout devtest
git pull upstream devtest
git checkout -b feature/your-feature-name

Making Changes and Writing Tests

Follow the code-style guidelines in the contribution docs: use meaningful variable names, keep functions small, and add comments for complex logic. Every change to the Rust backend requires corresponding unit or integration tests.

Run the full test suite before committing to ensure no regressions:

cargo test

Documentation and Commit Standards

Update relevant markdown documentation in README.md or docs/*.md if you modify public APIs or UI flows. Write commit messages using conventional commit format:

feat(audio): add high-res resampler
fix(transcription): resolve GPU memory leak
docs: update architecture diagrams

Submitting Your Pull Request

Push your branch and open a Pull Request targeting devtest. Fill out the PR template (lines 63-94 of CONTRIBUTING.md) and link related issues using Fixes #XYZ.

GitHub Actions workflows automatically run lint checks, tests, and build verification. Wait for maintainer review and address any feedback before the core team merges into devtest. Periodic merges from devtest to main are handled exclusively by the maintainers.

Key Contribution Areas

Focus your efforts on these active development zones based on your expertise:

Audio Pipeline

Refactor the mixing logic in frontend/src-tauri/src/audio/pipeline.rs, improve VAD accuracy, or add support for new audio devices. The recording manager in frontend/src-tauri/src/audio/recording_manager.rs orchestrates start/stop functionality.

Transcription Engine

Integrate new models or optimize GPU acceleration in frontend/src-tauri/src/whisper_engine/whisper_engine.rs and the Parakeet engine files.

Summary Generation

Add new LLM providers or tweak prompt templates in frontend/src-tauri/src/summary/processor.rs and frontend/src-tauri/src/summary/llm_client.rs.

UI/UX

Polish React components and state management in frontend/src/app/* and frontend/src/components/Sidebar/*.

Database

Implement schema migrations or performance tweaks in frontend/src-tauri/src/database/models.rs and database/manager.rs.

Code Examples

Registering a New Tauri Command

Add your command function in the appropriate Rust module, then register it in frontend/src-tauri/src/lib.rs:

#[tauri::command]
async fn toggle_noise_gate(enabled: bool) -> Result<(), String> {
    audio::engine::set_noise_gate(enabled);
    Ok(())
}

// In lib.rs
.invoke_handler(tauri::generate_handler![
    start_recording,
    toggle_noise_gate,   // ← add here
])

Calling Commands from the Frontend

Use the Tauri API to invoke registered commands from TypeScript:

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

export async function setNoiseGate(enabled: boolean) {
  await invoke('toggle_noise_gate', { enabled });
}

Writing Unit Tests for Rust Commands

Add test modules to verify your backend logic:

#[cfg(test)]
mod tests {
    use super::*;
    #[tokio::test]
    async fn test_noise_gate_toggle() {
        toggle_noise_gate(true).await.unwrap();
        assert!(audio::engine::is_noise_gate_enabled());
    }
}

Summary

• Target the devtest branch, never main, when creating feature branches
• Follow conventional commit messages and include tests for all Rust changes
• Key files: lib.rs for command registration, audio/pipeline.rs for audio processing, whisper_engine.rs for transcription, and summary/processor.rs for LLM integration
• Documentation: Update CONTRIBUTING.md and docs/architecture.md when changing public APIs
• Process: Fork → Branch from devtest → Code + Test → PR → Review → Merge

Frequently Asked Questions

What branch should I target when contributing to Meetily?

Always create your feature branches from devtest and set devtest as the base branch for your Pull Request. The main branch represents the stable release and only receives merges from the core team during scheduled releases.

Do I need to write tests for frontend changes?

While the contribution guidelines emphasize Rust unit tests for backend changes in frontend/src-tauri/src/, you should include integration tests for significant UI flows in the Next.js frontend. Run the full test suite with cargo test and any frontend test commands before submitting your PR.

How do I add a new LLM provider for summaries?

Modify frontend/src-tauri/src/summary/processor.rs and frontend/src-tauri/src/summary/llm_client.rs to implement the provider's API client. Follow the existing patterns for Ollama, Claude, or Groq integration, and update the configuration types to expose the new provider in the settings UI.

Where do I register new Tauri commands?

Define your command function with the #[tauri::command] attribute in the relevant module (such as audio or summary), then add the function name to the generate_handler! macro in frontend/src-tauri/src/lib.rs. Without this registration, the frontend cannot invoke the command.

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