Where to Find the Meetily Documentation: Complete File Reference Guide

Meetily's documentation is located entirely within the Zackriya-Solutions/meetily GitHub repository, organized in root-level files and a dedicated docs/ directory alongside extensive inline code comments in the Rust and TypeScript source files.

This guide maps every documentation resource in the open-source Meetily codebase, from high-level architecture diagrams to low-level API implementations. Whether you're an end user installing the app, a developer extending the transcription pipeline, or a contributor building from source, the repository contains version-controlled documentation for every use case.

Main Entry Points for Meetily Documentation

Root README.md: Your Starting Point

The README.md at the repository root serves as the primary landing page. It contains:

• Feature overview with animated screenshots
• Quick installation badges and download links
• Architecture summary with a link to the full system diagram
• Contribution guidelines and license information

Reference this file first for context before diving into implementation details.

The docs/ Directory: Developer-Focused Guides

The docs/ folder contains specialized documentation organized by topic:

File	Purpose	Key Contents
docs/architecture.md	System design reference	Mermaid diagrams, component breakdown (Next.js frontend, Tauri Rust core, audio engine, transcription engine, PostgreSQL database, summary engine)
docs/BUILDING.md	Compilation instructions	Platform-specific steps for macOS, Windows, and Linux with dependency matrices
docs/GPU_ACCELERATION.md	Performance optimization	CUDA, Vulkan, and Metal setup guides with error troubleshooting tables

All three files are maintained on the main branch and track exactly with the code they describe.

Source Code as Documentation

Meetily embeds substantial documentation directly in implementation files. The most critical references for understanding system behavior:

frontend/src-tauri/src/lib.rs: Tauri Command Reference

This file defines all frontend-to-backend IPC commands. The start_recording_with_devices_and_meeting function (lines 313-340) demonstrates the command registration pattern:

// Located in frontend/src-tauri/src/lib.rs
// Registers commands available to the TypeScript frontend
fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![
            start_recording_with_devices_and_meeting,
            stop_recording,
            // ... additional commands
        ])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

Study this file to understand:

• How the Tauri application bootstraps
• Which Rust functions are exposed to the frontend
• Plugin registration patterns (logging, window management)

frontend/src-tauri/src/audio/pipeline.rs: Audio Processing Logic

The core audio-mixing and Voice Activity Detection (VAD) transcription pipeline lives here. This file documents:

• Professional audio mixing for microphone and system sources
• Thread-safe state management for recording sessions
• Persistence hooks for transcript storage

Practical Documentation Usage Examples

Invoking a Rust Command from TypeScript

The frontend code in src/app/page.tsx demonstrates how documentation translates to implementation:

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

async function startMeeting() {
  // Matches the command registered in lib.rs
  await invoke('start_recording_with_devices_and_meeting', {
    mic_device_name: 'Built-in Microphone',
    system_device_name: 'BlackHole 2ch',
    meeting_name: 'Team Standup'
  });
}

Key insight: The string 'start_recording_with_devices_and_meeting' must exactly match the Rust function name in lib.rs. The parameter object keys correspond to the Rust function's arguments.

Building with GPU Acceleration on Linux

The docs/BUILDING.md file prescribes this workflow:

# Install system dependencies (Ubuntu/Debian)

sudo apt update && sudo apt install -y build-essential cmake git ffmpeg

# Clone and setup

git clone https://github.com/Zackriya-Solutions/meetily.git
cd meetily/frontend
pnpm install

# Build with automatic GPU detection

./build-gpu.sh

Auto-detection logic: The scripts/auto-detect-gpu.js helper checks for CUDA toolkit, Vulkan SDK, or Metal libraries, then sets RUSTFLAGS accordingly. Override manually when needed:

# Force specific GPU backend

TAURI_GPU_FEATURE=cuda ./build-gpu.sh    # Options: cuda, vulkan, metal, none

Development vs. Production Builds

Script	Purpose	Documentation Reference
./dev-gpu.sh	Hot-reload development with GPU acceleration	docs/BUILDING.md "Development Workflow" section
./build-gpu.sh	Optimized production binary	docs/BUILDING.md "Building for Distribution" section

Documentation Version Control Advantage

Because all Meetily documentation resides in the same Git repository as the source code:

• Commit precision: Reference docs/architecture.md at commit abc1234 to understand exactly how the system worked at that point
• Pull request review: Documentation changes ship with code changes, ensuring consistency
• Offline access: Clone once, read everywhere without network dependencies
• Issue cross-references: GitHub issues can link directly to file paths and line numbers

Navigate to any file on GitHub using the pattern:

https://github.com/Zackriya-Solutions/meetily/blob/main/[file-path]

Documentation Quick Reference Map

Your Goal	Start Here	Then Read
Install and use Meetily	README.md	docs/architecture.md for system understanding
Build from source	docs/BUILDING.md	docs/GPU_ACCELERATION.md if using NVIDIA/AMD GPUs
Understand audio processing	docs/architecture.md → "Audio Engine" section	frontend/src-tauri/src/audio/pipeline.rs
Add new Tauri commands	frontend/src-tauri/src/lib.rs	Tauri official docs for command patterns
Debug GPU errors	docs/GPU_ACCELERATION.md	Build logs and RUST_LOG=debug output
Contribute code	README.md → "Contributing" section	docs/architecture.md for design conventions

Summary

• Primary documentation lives in repository root README.md and docs/architecture.md, docs/BUILDING.md, docs/GPU_ACCELERATION.md
• API reference is embedded in frontend/src-tauri/src/lib.rs (commands) and frontend/src-tauri/src/audio/pipeline.rs (audio system)
• Version alignment: All documentation tracks with code on main branch; no external wiki or website to synchronize
• GPU builds: Use ./build-gpu.sh with optional TAURI_GPU_FEATURE override per docs/BUILDING.md

Frequently Asked Questions

Does Meetily have a separate documentation website?

No. Meetily follows docs-as-code principles, keeping all documentation in the Git repository. The README.md renders automatically on GitHub, and the docs/ folder provides structured guides. This ensures documentation and implementation never diverge.

How do I find documentation for a specific version?

Check out the corresponding Git tag or commit. All documentation files are version-controlled alongside source code. For example, to read docs for v1.2.0: git checkout v1.2.0 then open docs/BUILDING.md locally.

Where is the API reference for frontend-to-backend commands?

The authoritative reference is frontend/src-tauri/src/lib.rs. Each #[tauri::command] decorated function in this file is callable from TypeScript via invoke(). Parameter types and return structures are defined in the Rust function signatures.

What if the GPU acceleration documentation doesn't solve my build error?

First, verify your exact GPU model against the compatibility matrices in docs/GPU_ACCELERATION.md. Then check docs/BUILDING.md troubleshooting tables. For unresolved issues, the build scripts output detailed logs with RUST_LOG=debug—include these when opening a GitHub issue referencing your GPU and OS version.

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