# How to Contribute to Zackriya-Solutions/meetily: A Complete Developer's Guide

> Contribute to Zackriya-Solutions/meetily with our developer guide. Learn to fork, set up environments, branch, and submit pull requests. Start contributing today!

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

---

**To contribute to Zackriya-Solutions/meetily, fork the repository, set up Rust and Node.js development environments, create a feature branch, and submit a pull request following the guidelines in CONTRIBUTING.md.**

**Meetily** is a privacy-first AI meeting assistant built as a Tauri desktop application with a Rust core and Next.js/React frontend. Learning how to **contribute to Zackriya-Solutions/meetily** helps developers of all skill levels improve local AI-driven meeting transcription, audio processing, and cross-platform desktop functionality. The repository follows a modern mono-repo structure with clear separation between the Rust backend and TypeScript frontend.

## Development Environment Setup

Before writing code, you need the complete toolchain installed. The project combines **Rust** for the Tauri backend and **Node.js/pnpm** for the frontend build system.

### Prerequisites Installation

Install Rust via the official rustup installer:

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

```

Install Node.js and pnpm globally:

```bash
npm install -g pnpm

```

### Repository Setup

Fork the repository on GitHub, then clone your fork locally:

```bash
git clone https://github.com/<your-username>/meetily.git
cd meetily

```

Install frontend dependencies and start the development server:

```bash
cd frontend/
pnpm install
pnpm run tauri:dev

```

This command launches the full Tauri application with hot-reload enabled. The dev server watches both Rust source files in `frontend/src-tauri/src/` and TypeScript/React files in `frontend/src/app/`.

### GPU-Accelerated Development Builds

Meetily supports hardware-accelerated Whisper transcription. Choose the appropriate command for your platform:

```bash

# macOS with Apple Silicon (Metal/CoreML)

pnpm run tauri:dev:metal

# Linux with NVIDIA GPU (CUDA)

pnpm run tauri:dev:cuda

# Linux with AMD/Intel GPU (Vulkan)

pnpm run tauri:dev:vulkan

```

If GPU acceleration is unavailable, the **Whisper engine** 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) falls back to CPU inference automatically.

### Verify Your Installation

Run the Rust test suite to confirm everything works:

```bash
cargo test --workspace

```

This validates core logic including the audio pipeline, Whisper integration, and LLM clients.

## Contribution Workflow

The repository enforces quality through automated CI checks and clear conventions documented in [`CONTRIBUTING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/CONTRIBUTING.md).

### Read the Guidelines

Start by reviewing [`CONTRIBUTING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/CONTRIBUTING.md) in the repository root. This file contains the canonical contribution checklist, code-style conventions, and commit message format. The guidelines begin with "# Contributing to Meeting Minutes Updates" and outline expectations for all submissions.

### Branch and Code

Create a descriptively named branch:

```bash
git checkout -b fix/audio-mixing

# or

git checkout -b enhance/llm-context-window

```

Keep changes focused and isolated. A good contribution might:
- Fix a bug in [`audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/audio/pipeline.rs)
- Add a new Tauri command in [`lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/lib.rs)
- Extend the summarization logic in [`summary/service.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/summary/service.rs)

### Quality Checks

Before committing, run the full validation suite:

```bash

# Rust formatting and linting

cargo fmt
cargo clippy

# TypeScript linting (from frontend/ directory)

pnpm run lint

# Run tests

cargo test --workspace

```

### Commit and Submit

Follow **conventional commits** style:

```

feat: add real-time speaker diarization
fix: resolve audio drift in long recordings
docs: update build instructions for Ubuntu 24.04

```

Push your branch and open a pull request targeting `main`. Include:
- Clear description of changes
- Link to related issues
- Notes on testing performed

GitHub Actions workflows in `.github/workflows/` automatically run linting, tests, and cross-platform builds on every PR.

## Practical Code Examples

These patterns demonstrate how to extend Meetily's functionality.

### Adding a New Tauri Command

Tauri commands bridge the Rust backend with the JavaScript frontend. Register new commands in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs):

```rust
// src/lib.rs
#[tauri::command]
async fn my_new_command(arg: String) -> Result<String, String> {
    // your logic here …
    Ok(format!("You sent: {}", arg))
}

// Register the command in the builder
tauri::Builder::default()
    .invoke_handler(tauri::generate_handler![
        start_recording,
        my_new_command, // ← added
    ])
    .run(tauri::generate_context!())
    .expect("error while running tauri application");

```

Existing command patterns in [`lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/lib.rs) demonstrate error handling, state management, and async patterns used throughout the codebase.

### Extending the Audio Pipeline

The **AudioPipelineManager** in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) handles professional mixing and voice activity detection:

```rust
// audio/pipeline.rs – add a new processing step
impl AudioPipelineManager {
    pub async fn process_chunk(&mut self, chunk: AudioChunk) -> Result<()> {
        self.apply_ducking(&chunk)?;
        self.apply_vad(&chunk)?;
        // NEW: custom high-pass filter
        self.apply_high_pass(&chunk)?;
        self.distribute(chunk).await
    }
}

```

The pipeline already implements ducking, VAD, and multi-source mixing. New processing stages should follow this async pattern and preserve error propagation.

### Running GPU-Accelerated Whisper

Test local Whisper transcription with hardware acceleration:

```bash

# On macOS (Metal)

pnpm run tauri:dev:metal   # loads Whisper with CoreML acceleration

# On Linux with CUDA

pnpm run tauri:dev:cuda

```

The Whisper engine configuration in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) handles model loading, device selection, and transcription orchestration.

## Key Source Files for Contributors

Understanding the codebase structure accelerates effective contributions:

| File | Purpose |
|------|---------|
| [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) | Main Tauri entry point, registers all commands and events |
| [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) | Audio mixing, VAD, and professional processing pipeline |
| [`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) | Whisper model loading and transcription orchestration |
| [`frontend/src-tauri/src/summary/service.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/service.rs) | Summarization workflow and LLM client abstraction |
| [`frontend/src/app/page.tsx`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/app/page.tsx) | Frontend UI entry point (React component) |
| [`docs/architecture.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md) | High-level system diagram and component overview |
| [`CONTRIBUTING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/CONTRIBUTING.md) | Full contribution checklist and style guide |

## Platform-Specific Considerations

### macOS Permissions

macOS requires explicit user grants for both **microphone** and **screen-recording** permissions to capture system audio. The application prompts automatically during first run, but you can trigger the flow with `pnpm run tauri:dev`.

### Platform Modules

Audio device handling varies by operating system. Platform-specific implementations live in `audio/devices/platform/` subdirectories. If CI fails on a specific platform, verify the corresponding platform module compiles and passes tests.

### Cross-Platform Testing

The GitHub Actions workflows enforce builds on Linux, macOS, and Windows. Test locally with:

```bash

# Build for release (tests packaging)

pnpm run tauri:build

```

## Common Issues and Solutions

- **GPU backend unavailable**: Check hardware compatibility; CPU fallback works but slower
- **Audio permissions denied**: Reset macOS permissions in System Settings > Privacy & Security
- ** Rust compiler errors**: Run `rustup update` to ensure latest stable toolchain
- **pnpm lockfile conflicts**: Delete [`pnpm-lock.yaml`](https://github.com/Zackriya-Solutions/meetily/blob/main/pnpm-lock.yaml) and run `pnpm install` fresh
- **Test failures in CI**: Run `cargo test --workspace` locally before pushing

## Summary

To successfully **contribute to Zackriya-Solutions/meetily**:

- **Fork and clone** the repository, then install Rust and Node.js/pnpm
- **Review CONTRIBUTING.md** for project-specific conventions and commit message formats
- **Create focused branches** using `fix/` or `enhance/` prefixes
- **Run quality checks** with `cargo test`, `cargo clippy`, and `pnpm run lint` before submitting
- **Target the `main` branch** with clear PR descriptions linking related issues
- **Test GPU acceleration** when working on Whisper transcription features

The combination of Rust's performance for audio processing and TypeScript/React for UI creates a rewarding environment for full-stack contributors interested in privacy-preserving AI applications.

## Frequently Asked Questions

### What programming languages do I need to know to contribute to Meetily?

You need **Rust** for the Tauri backend and audio processing pipeline, plus **TypeScript/React** for the Next.js frontend. The codebase uses async Rust patterns and modern React hooks. Contributors can focus on either stack—frontend UI improvements or backend audio/AI logic—without deep expertise in both.

### How do I test GPU-accelerated transcription locally?

Use platform-specific pnpm commands: `pnpm run tauri:dev:metal` for Apple Silicon Macs, `pnpm run tauri:dev:cuda` for NVIDIA GPUs on Linux, or `pnpm run tauri:dev:vulkan` for AMD/Intel graphics. The Whisper engine in [`whisper_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/whisper_engine.rs) automatically selects the best available backend or falls back to CPU if hardware acceleration is unavailable.

### Where is the contribution checklist documented?

The **CONTRIBUTING.md** file in the repository root contains the complete contribution guide, starting with "# Contributing to Meeting Minutes Updates". It covers branch naming conventions, commit message formats, code style requirements, and the pull request process. The README's "Essential Development Commands" section also summarizes setup steps.

### What should I do if CI checks fail on my pull request?

First, run the full local validation: `cargo test --workspace`, `cargo clippy`, `cargo fmt`, and `pnpm run lint`. For platform-specific failures, check the corresponding audio device modules in `audio/devices/platform/`. The GitHub Actions workflows enforce cross-platform compatibility, so verify your changes compile on Linux, macOS, and Windows targets.