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

> Learn how to contribute to the Meetily project. Fork the repository, branch from devtest, and submit PRs with tests for Rust backend or Nextjs frontend changes.

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

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) |
| **Tauri Core (Rust)** | Window handling, command registration, and event dispatch | [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs) |
| **Database** | SQLite storage for meetings, transcripts, 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 integration (Ollama, Claude, Groq, OpenRouter) | [`frontend/src-tauri/src/summary/processor.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/processor.rs) |

For a visual overview, reference [`docs/architecture.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.

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

```bash
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:

```bash
cargo test

```

### Documentation and Commit Standards

Update relevant markdown documentation in [`README.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/processor.rs) and [`frontend/src-tauri/src/summary/llm_client.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/database/models.rs) and [`database/manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs):

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

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

```rust
#[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`](https://github.com/Zackriya-Solutions/meetily/blob/main/lib.rs) for command registration, [`audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/audio/pipeline.rs) for audio processing, [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) for transcription, and [`summary/processor.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/summary/processor.rs) for LLM integration
- **Documentation**: Update [`CONTRIBUTING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/CONTRIBUTING.md) and [`docs/architecture.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/processor.rs) and [`frontend/src-tauri/src/summary/llm_client.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs). Without this registration, the frontend cannot invoke the command.