How to Contribute to Meetily: A Step-by-Step Guide for Developers

To contribute to Meetily, fork the repository on GitHub, clone your local fork, create a feature branch from devtest, and open a pull request using the template in CONTRIBUTING.md after all CI checks pass.

Meetily is a privacy-first AI meeting assistant built as a single Tauri desktop application that tightly couples a Rust backend with a Next.js/React frontend. Learning how to contribute to Meetily effectively requires understanding this dual-stack architecture and targeting the devtest branch for all changes. The source is available at Zackriya-Solutions/meetily, with detailed developer guidelines in CONTRIBUTING.md and docs/architecture.md.

Understand the Meetily Architecture

Before writing code, map out how the components interact. The application is split into a React-based UI layer and a Rust-powered engine layer that handles audio, transcription, and LLM summaries.

Frontend Next.js Layer

The Next.js frontend manages the meeting UI, transcript display, and settings screens. It communicates with the operating system through Tauri commands and events rather than a traditional REST API.

Key file: frontend/src/app/page.tsx

Rust Backend and Tauri Core

The Tauri core written in Rust handles window management, command registration, and event dispatch. Each frontend request routes through Tauri invoke handlers defined in the backend.

Key file: frontend/src-tauri/src/lib.rs

Audio, Transcription, and Summary Engines

Beneath the UI, several specialized engines run locally:

• Audio Engine — Captures microphone and system audio, mixes streams professionally, and applies voice-activity detection (VAD). Refer to frontend/src-tauri/src/audio/pipeline.rs.
• Transcription Engine — Runs Whisper or Parakeet locally with GPU acceleration when available. Refer to frontend/src-tauri/src/whisper_engine/whisper_engine.rs.
• Summary Engine — Calls LLM providers such as Ollama, Claude, Groq, OpenRouter, or custom OpenAI-compatible endpoints to generate meeting summaries. Refer to frontend/src-tauri/src/summary/processor.rs.
• Database Layer — Persists meetings, transcripts, and summaries in SQLite. Refer to frontend/src-tauri/src/database/models.rs.

Development Workflow

The project follows a structured workflow defined in CONTRIBUTING.md.

Fork and Clone the Repository

Start by creating a personal fork and cloning it locally:

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

Setup instructions are in the Getting Started section of CONTRIBUTING.md.

Branch Against devtest

All contributor work branches from devtest. Do not open pull requests against main.

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

Branch rules are outlined in lines 7–12 of CONTRIBUTING.md.

Write Code and Tests

Follow the code-style guidelines: use meaningful names, keep functions small, and add comments for complex logic. Add or update unit and integration tests for any changed behavior, then run the full test suite to verify nothing breaks.

Update Documentation

If your change touches public APIs, UI flows, or architecture decisions, keep related markdown docs in sync. Update README.md or files under docs/*.md as needed.

Commit and Open a Pull Request

Write clear, conventional commit messages. For example:

git commit -m "feat(audio): add high-res resampler"

Push your branch and open a pull request targeting devtest. Fill out the PR template (lines 63–94 of CONTRIBUTING.md) and link the related issue with Fixes #XYZ.

CI Checks and Maintainer Review

GitHub Actions automatically runs lint, tests, and build checks on every PR. Wait for at least one maintainer review and address any feedback before the team merges your contribution into devtest. Periodic merges from devtest to main are handled by the core team.

Key Contribution Areas

The repository is organized into clear domains where contributors can focus:

• Audio pipeline — Refactor mixing logic, improve VAD accuracy, or add new audio device support. Important files: frontend/src-tauri/src/audio/pipeline.rs and audio/v2/*.
• Transcription — Integrate new speech-to-text models or optimize GPU acceleration paths. Important files: frontend/src-tauri/src/whisper_engine/whisper_engine.rs and parakeet_engine/*.
• Summary generation — Add new LLM providers or refine prompt templates. Important files: frontend/src-tauri/src/summary/processor.rs and summary/llm_client.rs.
• UI/UX — Polish React components, improve accessibility, or refine state management. Important files: frontend/src/app/* and frontend/src/components/Sidebar/*.
• Database — Write schema migrations or apply performance tweaks. Important files: frontend/src-tauri/src/database/models.rs and database/manager.rs.
• Documentation — Author new guides, architecture diagrams, or update screenshots. Important files: README.md and docs/*.

Code Examples for Meetily Contributors

Create a Feature Branch

git checkout devtest
git pull upstream devtest
git checkout -b feature/audio-ducking-improvement

Register a New Tauri Command in Rust

In the Rust backend, expose a new command:

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

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

Call the Command from the Frontend

Use the Tauri API to invoke the registered command from TypeScript:

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

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

Add a Rust Unit Test

Verify backend behavior with an async test:

#[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());
    }
}

Essential Files Every Contributor Should Know

Understanding these paths accelerates onboarding:

• frontend/src-tauri/src/lib.rs — Central command registration and Tauri setup.
• frontend/src-tauri/src/audio/pipeline.rs — Core of the professional audio mixing and VAD logic.
• frontend/src-tauri/src/audio/recording_manager.rs — Orchestrates start and stop of recordings.
• frontend/src-tauri/src/summary/processor.rs — Handles the summary generation workflow.
• frontend/src-tauri/src/whisper_engine/whisper_engine.rs — Transcription engine entry point.
• CONTRIBUTING.md — Full contribution policy and PR checklist.
• docs/architecture.md — High-level design overview and visual system map.
• frontend/src/app/page.tsx — Example UI page that invokes Tauri commands.

Summary

• Fork the repository and always branch from devtest, not main.
• Meetily combines a Next.js frontend with a Rust/Tauri backend handling audio, transcription, and summaries.
• Follow conventional commit messages, fill out the PR template from CONTRIBUTING.md, and link related issues with Fixes #XYZ.
• Key files include frontend/src-tauri/src/lib.rs for command registration and frontend/src-tauri/src/audio/pipeline.rs for audio processing.
• Add tests for Rust changes and update markdown docs when altering public APIs or UI flows.

Frequently Asked Questions

What branch should I target when contributing to Meetily?

Always create your feature branch from devtest and open pull requests against devtest. The core maintainers periodically merge devtest into main after review cycles.

Do I need to know Rust to contribute to Meetily?

No. While backend changes to the audio pipeline, transcription engine, or Tauri command layer require Rust, you can contribute to the Next.js/React frontend, documentation, or design without writing Rust.

How do I register a new command in the Rust backend?

Annotate a function with #[tauri::command], add it to the invoke_handler inside frontend/src-tauri/src/lib.rs, and call it from the frontend using invoke from @tauri-apps/api/tauri.

Where are the contribution guidelines and PR template located?

The full policy is in CONTRIBUTING.md at the repository root. The PR template appears on lines 63–94 of that file, and setup instructions are in the Getting Started section.

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