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

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:

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

Install Node.js and pnpm globally:

npm install -g pnpm

Repository Setup

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

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

Install frontend dependencies and start the development server:

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:

# 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 falls back to CPU inference automatically.

Verify Your Installation

Run the Rust test suite to confirm everything works:

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.

Read the Guidelines

Start by reviewing 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:

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
• Add a new Tauri command in lib.rs
• Extend the summarization logic in summary/service.rs

Quality Checks

Before committing, run the full validation suite:

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

// 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 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 handles professional mixing and voice activity detection:

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

# 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 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	Main Tauri entry point, registers all commands and events
frontend/src-tauri/src/audio/pipeline.rs	Audio mixing, VAD, and professional processing pipeline
frontend/src-tauri/src/whisper_engine/whisper_engine.rs	Whisper model loading and transcription orchestration
frontend/src-tauri/src/summary/service.rs	Summarization workflow and LLM client abstraction
frontend/src/app/page.tsx	Frontend UI entry point (React component)
docs/architecture.md	High-level system diagram and component overview
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:

# 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 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 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.

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