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

> Learn how to contribute to Meetily with this step-by-step developer guide. Fork, clone, branch, and submit your pull request effortlessly to join the project.

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

---

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

## 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/database/models.rs).

## Development Workflow

The project follows a structured workflow defined in [`CONTRIBUTING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/CONTRIBUTING.md).

### Fork and Clone the Repository

Start by creating a personal fork and cloning it locally:

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

```

Setup instructions are in the *Getting Started* section of [`CONTRIBUTING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/CONTRIBUTING.md).

### Branch Against `devtest`

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

```bash
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/README.md) or files under `docs/*.md` as needed.

### Commit and Open a Pull Request

Write clear, conventional commit messages. For example:

```bash
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/processor.rs) and [`summary/llm_client.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](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).
- **Documentation** — Author new guides, architecture diagrams, or update screenshots. Important files: [`README.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/README.md) and `docs/*`.

## Code Examples for Meetily Contributors

### Create a Feature Branch

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

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

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

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

```

## Essential Files Every Contributor Should Know

Understanding these paths accelerates onboarding:

- [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) — Central command registration and Tauri setup.
- [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) — Core of the professional 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) — Orchestrates start and stop of recordings.
- [`frontend/src-tauri/src/summary/processor.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/processor.rs) — Handles the summary generation workflow.
- [`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) — Transcription engine entry point.
- [`CONTRIBUTING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/CONTRIBUTING.md) — Full contribution policy and PR checklist.
- [`docs/architecture.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md) — High-level design overview and visual system map.
- [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/CONTRIBUTING.md), and link related issues with `Fixes #XYZ`.
- Key files include [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) for command registration and [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.