meetily Documentation

Privacy first, AI meeting assistant with 4x faster Parakeet/Whisper live transcription, speaker diarization, and Ollama summarization built on Rust.

11,648 stars

Rust 1 file · ~10,414 tokens #ai #ai-meeting-assistant #llm #local-ai #mac #meeting-minutes #meeting-notes #offline-first

RAW Doc

Docker & Self-Hosted Deployment Verified OCI

Deploy meetily on any server, homelab, or cloud container platform.

Raw YAML Docker Page → JSON API

1-Click Terminal Command

bash (docker run)

docker run -d --name meetily -p 8178:8178 --restart always meetily-backend:latest

Configured Services & Ports

⚙️ whisper-server

image: whisper-server:${TAG:-cpu}

🔌 Ports: ${WHISPER_PORT:-8178}:8178

⚙️ whisper-server-macos

image: whisper-server:macos

🔌 Ports: ${WHISPER_PORT:-8178}:8178

⚙️ model-downloader

image: alpine/curl:latest

⚙️ meetily-backend

image: meetily-backend:latest

🔌 Ports: ${APP_PORT:-5167}:5167

⚙️ meetily-backend-macos

image: meetily-backend:latest

🔌 Ports: ${APP_PORT:-5167}:5167

⚙️ web-ui

image: nginx:alpine

🔌 Ports: ${WEB_PORT:-80}:80

docker-compose.yml

yaml (docker-compose.yml)

version: '3.8'

# ⚠️  AUDIO PROCESSING WARNING:
# Docker containers with insufficient resources will drop audio chunks when
# the processing queue becomes full (MAX_AUDIO_QUEUE_SIZE=10, lib.rs:54).
# Symptoms: "Dropped old audio chunk" in logs (lib.rs:330-333).
# 
# RECOMMENDED RESOURCE ALLOCATION:
# - Memory: 8GB minimum per service (16GB total recommended)
# - CPU: 2+ cores per service
# - Monitor logs for audio drop warnings during operation

services:
  # Original whisper-server service (Windows/Linux compatibility)
  whisper-server:
    build:
      context: .
      dockerfile: ${DOCKERFILE:-Dockerfile.server-cpu}
      args:
        CUDA_VERSION: ${CUDA_VERSION:-12.3.1}
        UBUNTU_VERSION: ${UBUNTU_VERSION:-22.04}
    image: whisper-server:${TAG:-cpu}
    container_name: whisper-server
    restart: unless-stopped
    
    # Port mapping
    ports:
      - "${WHISPER_PORT:-8178}:8178"
    
    # Environment variables
    environment:
      - WHISPER_HOST=0.0.0.0
      - WHISPER_PORT=8178
      - WHISPER_MODEL=${WHISPER_MODEL:-models/ggml-base.en.bin}
      - WHISPER_THREADS=${WHISPER_THREADS:-0}
      - WHISPER_USE_GPU=${WHISPER_USE_GPU:-true}
      - WHISPER_LANGUAGE=${WHISPER_LANGUAGE:-en}
      - WHISPER_TRANSLATE=${WHISPER_TRANSLATE:-false}
      - WHISPER_DIARIZE=${WHISPER_DIARIZE:-false}
      - WHISPER_PRINT_PROGRESS=${WHISPER_PRINT_PROGRESS:-true}
    
    # Volume mounts
    volumes:
      # Model storage - persistent across container restarts
      - whisper_models:/app/models
      # Upload directory for temporary files
      - whisper_uploads:/app/uploads
      # Optional: mount local models directory
      - ${LOCAL_MODELS_DIR:-./models}:/app/local_models:ro
      # Optional: mount custom configuration
      - ${CONFIG_DIR:-./config}:/app/config:ro
    
    # Exclude from macOS profile
    profiles:
      - default

  # macOS-optimized whisper-server service
  whisper-server-macos:
    build:
      context: .
      dockerfile: Dockerfile.server-macos
    image: whisper-server:macos
    container_name: whisper-server
    restart: unless-stopped
    
    # Port mapping
    ports:
      - "${WHISPER_PORT:-8178}:8178"
    
    # Environment variables (GPU disabled for macOS)
    environment:
      - WHISPER_HOST=0.0.0.0
      - WHISPER_PORT=8178
      - WHISPER_MODEL=${WHISPER_MODEL:-models/ggml-large-v3.bin}
      - WHISPER_THREADS=${WHISPER_THREADS:-0}
      - WHISPER_USE_GPU=false
      - WHISPER_LANGUAGE=${WHISPER_LANGUAGE:-en}
      - WHISPER_TRANSLATE=${WHISPER_TRANSLATE:-false}
      - WHISPER_DIARIZE=${WHISPER_DIARIZE:-false}
      - WHISPER_PRINT_PROGRESS=${WHISPER_PRINT_PROGRESS:-true}
      - WHISPER_PLATFORM=macos
    
    # Volume mounts for macOS (using actual models directory)
    volumes:
      # Map to actual model location on macOS
      - ./models:/app/models
      # Upload directory for temporary files
      - whisper_uploads:/app/uploads
      # Optional: mount custom configuration
      - ${CONFIG_DIR:-./config}:/app/config:ro
    
    # macOS profile only
    profiles:
      - macos
    
    # GPU support (uncomment for GPU version)
    # deploy:
    #   resources:
    #     reservations:
    #       devices:
    #         - driver: nvidia
    #           count: all
    #           capabilities: [gpu]
    
    # Health check
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8178/"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    
    # Resource limits (optional)
    mem_limit: 4g
    mem_reservation: 1g
    
    # Logging configuration
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

  # Model downloader service - ensures models are downloaded before whisper server starts
  model-downloader:
    image: alpine/curl:latest
    container_name: whisper-model-downloader
    volumes:
      - whisper_models:/models
    environment:
      - MODEL_NAME=${MODEL_NAME:-base.en}
    command: |
      sh -c "
        echo '🔍 Checking for model: ggml-\${MODEL_NAME}.bin'
        if [ ! -f /models/ggml-\${MODEL_NAME}.bin ] || [ ! -s /models/ggml-\${MODEL_NAME}.bin ]; then
          echo '📦 Downloading model: \${MODEL_NAME}...'
          echo '📋 This may take a few minutes depending on model size and connection speed'
          # Create temp file to avoid partial downloads
          curl -L -f --progress-bar \
            --connect-timeout 30 \
            --max-time 3600 \
            --retry 3 \
            --retry-delay 5 \
            --retry-connrefused \
            -o /models/ggml-\${MODEL_NAME}.bin.tmp \
            https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-\${MODEL_NAME}.bin
          
          # Verify download completed successfully  
          if [ -s /models/ggml-\${MODEL_NAME}.bin.tmp ]; then
            mv /models/ggml-\${MODEL_NAME}.bin.tmp /models/ggml-\${MODEL_NAME}.bin
            echo '✅ Model downloaded successfully: \${MODEL_NAME}'
            ls -lh /models/ggml-\${MODEL_NAME}.bin
          else
            echo '❌ Download failed or file is empty'
            rm -f /models/ggml-\${MODEL_NAME}.bin.tmp
            exit 1
          fi
        else
          echo '✅ Model already exists: \${MODEL_NAME}'
          ls -lh /models/ggml-\${MODEL_NAME}.bin
        fi
        echo '🎉 Model preparation complete'
      "
    healthcheck:
      test: ["CMD", "test", "-f", "/models/ggml-${MODEL_NAME:-base.en}.bin"]
      interval: 10s
      timeout: 5s
      retries: 1
    profiles:
      - download

  # Meeting Summarizer Python App (Windows/Linux)
  meetily-backend:
    build:
      context: .
      dockerfile: Dockerfile.app
    image: meetily-backend:latest
    container_name: meetily-backend
    restart: unless-stopped
    
    # Port mapping
    ports:
      - "${APP_PORT:-5167}:5167"
    
    # Environment variables
    environment:
      - PYTHONUNBUFFERED=1
      - PYTHONPATH=/app
      - DATABASE_PATH=/app/data/meeting_minutes.db
      - OLLAMA_HOST=${OLLAMA_HOST:-http://host.docker.internal:11434}
    
    # Add extra host for Docker Desktop compatibility
    extra_hosts:
      - "host.docker.internal:host-gateway"
    
    # Volume mounts
    volumes:
      # Local database directory (created by setup-db.sh)
      - ./data:/app/data
      # Logs directory
      - meeting_app_logs:/app/logs
      # Optional: mount local .env file
      - ${LOCAL_ENV_FILE:-./app/.env}:/app/.env:ro
    
    # Health check
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5167/get-meetings"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    
    # Resource limits (optional)
    mem_limit: 2g
    mem_reservation: 512m
    
    # Logging configuration
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    
    # Depends on whisper server for transcription
    depends_on:
      whisper-server:
        condition: service_healthy
    
    # Exclude from macOS profile
    profiles:
      - default

  # Meeting Summarizer Python App (macOS)
  meetily-backend-macos:
    build:
      context: .
      dockerfile: Dockerfile.app
    image: meetily-backend:latest
    container_name: meetily-backend
    restart: unless-stopped
    
    # Port mapping
    ports:
      - "${APP_PORT:-5167}:5167"
    
    # Environment variables
    environment:
      - PYTHONUNBUFFERED=1
      - PYTHONPATH=/app
      - DATABASE_PATH=/app/data/meeting_minutes.db
      - OLLAMA_HOST=${OLLAMA_HOST:-http://host.docker.internal:11434}
    
    # Add extra host for Docker Desktop compatibility
    extra_hosts:
      - "host.docker.internal:host-gateway"
    
    # Volume mounts
    volumes:
      # Local database directory (created by setup-db.sh)
      - ./data:/app/data
      # Logs directory
      - meeting_app_logs:/app/logs
      # Optional: mount local .env file
      - ${LOCAL_ENV_FILE:-./app/.env}:/app/.env:ro
    
    # Health check
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5167/get-meetings"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    
    # Resource limits (optional)
    mem_limit: 2g
    mem_reservation: 512m
    
    # Logging configuration
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"
    
    # Depends on macOS whisper server for transcription
    depends_on:
      whisper-server-macos:
        condition: service_healthy
    
    # macOS profile only
    profiles:
      - macos

  # Optional: Web UI service (if you want a separate frontend)
  web-ui:
    image: nginx:alpine
    container_name: whisper-web-ui
    ports:
      - "${WEB_PORT:-80}:80"
    volumes:
      - ./web:/usr/share/nginx/html:ro
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - whisper-server
      - meetily-backend
    profiles:
      - web

# Named volumes for persistent data
volumes:
  whisper_models:
    driver: local
  whisper_uploads:
    driver: local
  meeting_app_logs:
    driver: local

# Networks (optional)
networks:
  default:
    name: whisper-network

File: README.md

Meetily PRO Upgrade Offer - Meetily PRO is available for users who need enhanced accuracy, advanced exports, custom summary workflows, and team-ready features. Use coupon code LAUNCH20 for 20% off until the next Meetily Community Edition release. Speaker diarization is also planned for PRO in mid-June. Explore Meetily PRO →

Table of Contents

Introduction
Why Meetily?
Features
Installation
Key Features in Action
System Architecture
For Developers
Meetily PRO
Contributing
License

Introduction

Meetily is a privacy-first AI meeting assistant that runs entirely on your local machine. It captures your meetings, transcribes them in real-time, and generates summaries, all without sending any data to the cloud. This makes it the perfect solution for professionals and enterprises who need to maintain complete control over their sensitive information.

Why Meetily?

While there are many meeting transcription tools available, this solution stands out by offering:

Privacy First: All processing happens locally on your device.
Cost-Effective: Uses open-source AI models instead of expensive APIs.
Flexible: Works offline and supports multiple meeting platforms.
Customizable: Self-host and modify for your specific needs.

The Privacy Problem

Meeting AI tools create significant privacy and compliance risks across all sectors:

$4.4M average cost per data breach (IBM 2024)
€5.88 billion in GDPR fines issued by 2025
400+ unlawful recording cases filed in California this year

Whether you're a defense consultant, enterprise executive, legal professional, or healthcare provider, your sensitive discussions shouldn't live on servers you don't control. Cloud meeting tools promise convenience but deliver privacy nightmares with unclear data storage practices and potential unauthorized access.

Meetily solves this: Complete data sovereignty on your infrastructure, zero vendor lock-in, and full control over your sensitive conversations.

Features

Local First: All processing is done on your machine. No data ever leaves your computer.
Real-time Transcription: Get a live transcript of your meeting as it happens.
AI-Powered Summaries: Generate summaries of your meetings using powerful language models.
Multi-Platform: Works on macOS, Windows, and Linux.
Open Source: Meetily is open source and free to use.
Flexible AI Provider Support: Choose from Ollama (local), Claude, Groq, OpenRouter, or use your own OpenAI-compatible endpoint.

Installation

🪟 Windows

Download the latest x64-setup.exe from Releases
Run the installer

🍎 macOS

Download meetily_0.4.0_aarch64.dmg from Releases
Open the downloaded .dmg file
Drag Meetily to your Applications folder
Open Meetily from Applications folder

🐧 Linux

Build from source following our detailed guides:

Quick start:

bash

git clone https://github.com/Zackriya-Solutions/meeting-minutes
cd meeting-minutes/frontend
pnpm install
./build-gpu.sh

Key Features in Action

🎯 Local Transcription

Transcribe meetings entirely on your device using Whisper or Parakeet models. No cloud required.

📥 Import & Enhance `Beta`

Import existing audio files to generate transcripts, or enhance to re-transcribe any recorded meeting with a different model or language, all processed locally.

Contributed by Jeremi Joslin, improved by Vishnu P S and Mohammed Safvan

🤖 AI-Powered Summaries

Generate meeting summaries with your choice of AI provider. Ollama (local) is recommended, with support for Claude, Groq, OpenRouter, and OpenAI.

🔒 Privacy-First Design

All data stays on your machine. Transcription models, recordings, and transcripts are stored locally.

🌐 Custom OpenAI Endpoint Support

Use your own OpenAI-compatible endpoint for AI summaries. Perfect for organizations with custom AI infrastructure or preferred providers.

🎙️ Professional Audio Mixing

Capture microphone and system audio simultaneously with intelligent ducking and clipping prevention.

⚡ GPU Acceleration

Built-in support for hardware acceleration across platforms:

macOS: Apple Silicon (Metal) + CoreML
Windows/Linux: NVIDIA (CUDA), AMD/Intel (Vulkan)

Automatically enabled at build time - no configuration needed.

System Architecture

Meetily is a single, self-contained application built with Tauri. It uses a Rust-based backend to handle all the core logic, and a Next.js frontend for the user interface.

For more details, see the Architecture documentation.

For Developers

If you want to contribute to Meetily or build it from source, you'll need to have Rust and Node.js installed. For detailed build instructions, please see the Building from Source guide.

Meetily Pro

Meetily PRO is a professional-grade solution with enhanced accuracy and advanced features for serious users and teams. Built on a different codebase with superior transcription models and enterprise-ready capabilities.

Community Thank-You Offer

Meetily Community Edition will remain free and open source. PRO exists for users and teams who want a more advanced meeting workflow, including higher transcription accuracy, custom summary templates, advanced exports, auto-meeting detection, and self-hosted deployment options.

For the community that helped Meetily grow, we are making the upgrade easier: use coupon code LAUNCH20 for 20% off Meetily PRO until the next Meetily Community Edition release.

Speaker diarization is planned for mid-June, bringing automatic speaker separation to PRO meetings.

Key Advantages Over Community Edition:

Enhanced Accuracy: Superior transcription models for professional-grade accuracy
Custom Summary Templates: Tailor summaries to your specific workflow and needs
Advanced Export Options: PDF, DOCX, and Markdown exports with formatting
Auto-detect and Join Meetings: Automatic meeting detection and joining
Speaker Identification: Distinguish between speakers automatically (Coming Soon)
Chat with Meetings: AI-powered meeting insights and queries (Coming Soon)
Calendar Integration: Seamless integration with your calendar (Coming Soon)
Self-Hosted Deployment: Deploy on your own infrastructure for teams
GDPR Compliance Built-In: Privacy by design architecture with complete audit trails
Priority Support: Dedicated support for PRO users

Who is PRO for?

Professionals who need the highest accuracy for critical meetings
Teams and organizations (2-100 users) requiring self-hosted deployment
Power users who need advanced export formats and custom workflows
Compliance-focused organizations requiring GDPR readiness

Note: Meetily Community Edition remains free & open source forever with local transcription, AI summaries, and core features. PRO is a separate professional solution for users who need enhanced accuracy and advanced capabilities.

For organizations needing 100+ users or managed compliance solutions, explore Meetily Enterprise.

Learn more about pricing and features: https://meetily.ai/pro/

Contributing

We welcome contributions from the community! If you have any questions or suggestions, please open an issue or submit a pull request. Please follow the established project structure and guidelines. For more details, refer to the CONTRIBUTING.md file.

Thanks for all the contributions. Our community is what makes this project possible.

License

MIT License - Feel free to use this project for your own purposes.

Acknowledgments

We borrowed some code from Whisper.cpp.
We borrowed some code from Screenpipe.
We borrowed some code from transcribe-rs.
Thanks to NVIDIA for developing the Parakeet model.
Thanks to istupakov for providing the ONNX conversion of the Parakeet model.

Star History

File: backend/whisper-custom/server/README.md

whisper.cpp/examples/server

Simple http server. WAV Files are passed to the inference model via http requests.

https://github.com/ggerganov/whisper.cpp/assets/1991296/e983ee53-8741-4eb5-9048-afe5e4594b8f

Usage

text

/* Detailed source-code truncated for AI context efficiency. */

[!WARNING]
Do not run the server example with administrative privileges and ensure it's operated in a sandbox environment, especially since it involves risky operations like accepting user file uploads and using ffmpeg for format conversions. Always validate and sanitize inputs to guard against potential security threats.

request examples

/inference

text

curl 127.0.0.1:8080/inference \
-H "Content-Type: multipart/form-data" \
-F file="@<file-path>" \
-F temperature="0.0" \
-F temperature_inc="0.2" \
-F response_format="json"

/load

text

curl 127.0.0.1:8080/load \
-H "Content-Type: multipart/form-data" \
-F model=""

File: backend/README.md

Legacy Backend Archive

This directory contains the archived Python/FastAPI, Docker, and standalone
whisper-server backend implementation from older Meetily releases.

Current Supported Architecture

Meetily no longer uses this backend as the supported application path. The
current app is a self-contained Tauri desktop application:

Next.js provides the desktop UI from frontend/src.
Rust/Tauri provides the local backend and native integration from
frontend/src-tauri.
Local transcription, meeting storage, and summary workflows are handled by
the bundled desktop app rather than a separate FastAPI service.

Use these docs for supported setup and development:

Status of This Directory

The files under backend/ are retained only for historical reference and
legacy migration context. They should not be used for new installs, production
deployments, security assessments of the supported app, or contributor setup.

The old FastAPI service, Docker compose flow, standalone whisper-server flow,
and related scripts are unsupported. The old unauthenticated FastAPI/CORS
behavior must not be treated as a supported production API.

File: docs/architecture.md

System Architecture

Meetily is a self-contained desktop application built with Tauri. It combines a Rust-based backend with a Next.js frontend into a single, efficient, and cross-platform application.

High-Level Architecture Diagram

mermaid

graph TD
    subgraph User Interface
        A[Next.js Frontend]
    end

    subgraph "Core Logic (Rust)"
        B[Tauri Core]
        C[Audio Engine]
        D[Transcription Engine]
        E[Database]
        F[Summary Engine]
    end

    A -- Tauri Commands --> B
    B -- Manages --> C
    B -- Manages --> D
    B -- Manages --> E
    B -- Manages --> F

Component Details

Frontend (Next.js)

Provides the user interface for managing meetings, displaying transcriptions, and configuring the application.
Communicates with the Rust core through Tauri's command system.

Backend (Rust Core)

Tauri Core: The heart of the application, responsible for managing the window, handling events, and exposing the Rust core to the frontend.
Audio Engine: Captures audio from the microphone and system, processes it, and prepares it for transcription.
Transcription Engine: Uses local speech-to-text models (Whisper or Parakeet) to transcribe the captured audio. It can be accelerated with a GPU.
Database: A local SQLite database that stores meeting metadata, transcripts, and summaries.
Summary Engine: Generates meeting summaries using various Large Language Models (LLMs), including local models via Ollama.

File: docs/BUILDING.md

Building Meetily from Source

This guide provides detailed instructions for building Meetily from source on different operating systems.

Linux

🐧 Building on Linux

This guide helps you build Meetily on Linux with automatic GPU acceleration. The build system detects your hardware and configures the best performance automatically.

🚀 Quick Start (Recommended for Beginners)

If you're new to building on Linux, start here. These simple commands work for most users:

1. Install Basic Dependencies

bash

# Ubuntu/Debian
sudo apt update
sudo apt install build-essential cmake git

# Fedora/RHEL
sudo dnf install gcc-c++ cmake git

# Arch Linux
sudo pacman -S base-devel cmake git

2. Build and Run

bash

# Development mode (with hot reload)
./dev-gpu.sh

# Production build
./build-gpu.sh

That's it! The scripts automatically detect your GPU and configure acceleration.

What Happens Automatically?

✅ NVIDIA GPU → CUDA acceleration (if toolkit installed)
✅ AMD GPU → ROCm acceleration (if ROCm installed)
✅ No GPU → Optimized CPU mode (still works great!)

💡 Tip: If you have an NVIDIA or AMD GPU but want better performance, jump to the GPU Setup section below.

🧠 Understanding Auto-Detection

The build scripts (dev-gpu.sh and build-gpu.sh) orchestrate the entire build process. Here's how they work:

Detect location: Find package.json (works from project root or frontend/)
Auto-detect GPU: Run scripts/auto-detect-gpu.js (or use TAURI_GPU_FEATURE if set)
Build Sidecar: Build llama-helper with the detected feature (debug or release)
Copy Binary: Copy the built sidecar to src-tauri/binaries with the target triple
Run Tauri: Call npm run tauri:dev or tauri:build with the feature flag passed via env var

Detection Priority

Priority	Hardware	What It Checks	Result
1️⃣	NVIDIA CUDA	`nvidia-smi` exists + (`CUDA_PATH` or `nvcc` found)	`--features cuda`
2️⃣	AMD ROCm	`rocm-smi` exists + (`ROCM_PATH` or `hipcc` found)	`--features hipblas`
3️⃣	Vulkan	`vulkaninfo` exists + `VULKAN_SDK` + `BLAS_INCLUDE_DIRS` set	`--features vulkan`
4️⃣	OpenBLAS	`BLAS_INCLUDE_DIRS` set	`--features openblas`
5️⃣	CPU-only	None of the above	(no features, pure CPU)

Common Scenarios

Your System	Auto-Detection Result	Why
Clean Linux install	CPU-only	No GPU SDK detected
NVIDIA GPU + drivers only	CPU-only	CUDA toolkit not installed
NVIDIA GPU + CUDA toolkit	CUDA acceleration ✅	Full detection successful
AMD GPU + ROCm	HIPBlas acceleration ✅	Full detection successful
Vulkan drivers only	CPU-only	Vulkan SDK + env vars needed
Vulkan SDK configured	Vulkan acceleration ✅	All requirements met

💡 Key Insight: Having GPU drivers alone isn't enough. You need the development SDK (CUDA toolkit, ROCm, or Vulkan SDK) for acceleration.

🔧 GPU Setup Guides (Intermediate)

Want better performance? Follow these guides to enable GPU acceleration.

🟢 NVIDIA CUDA Setup

Prerequisites: NVIDIA GPU with compute capability 5.0+ (check: nvidia-smi --query-gpu=compute_cap --format=csv)

Step 1: Install CUDA Toolkit

bash

# Ubuntu/Debian (CUDA 12.x)
sudo apt install nvidia-driver-550 nvidia-cuda-toolkit

# Verify installation
nvidia-smi          # Shows GPU info
nvcc --version      # Shows CUDA version

Step 2: Build with CUDA

bash

# Set your GPU's compute capability
# Example: RTX 3080 = 8.6 → use "86"
# Example: GTX 1080 = 6.1 → use "61"

CMAKE_CUDA_ARCHITECTURES=75 \
CMAKE_CUDA_STANDARD=17 \
CMAKE_POSITION_INDEPENDENT_CODE=ON \
./build-gpu.sh

💡 Finding Your Compute Capability:
bash
nvidia-smi --query-gpu=compute_cap --format=csv
Convert 7.5 → 75, 8.6 → 86, etc.

Why these flags?

CMAKE_CUDA_ARCHITECTURES: Optimizes for your specific GPU
CMAKE_CUDA_STANDARD=17: Ensures C++17 compatibility
CMAKE_POSITION_INDEPENDENT_CODE=ON: Fixes linking issues on modern systems

🔵 Vulkan Setup (Cross-Platform Fallback)

Vulkan works on NVIDIA, AMD, and Intel GPUs. Good choice if CUDA/ROCm don't work.

Step 1: Install Vulkan SDK and BLAS

bash

# Ubuntu/Debian
sudo apt install vulkan-sdk libopenblas-dev

# Fedora
sudo dnf install vulkan-devel openblas-devel

# Arch Linux
sudo pacman -S vulkan-devel openblas

Step 2: Configure Environment

bash

# Add to ~/.bashrc or ~/.zshrc
export VULKAN_SDK=/usr
export BLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu

# Apply changes
source ~/.bashrc

Step 3: Build

bash

./build-gpu.sh

The script will automatically detect Vulkan and build with --features vulkan.

🔴 AMD ROCm Setup (AMD GPUs Only)

Prerequisites: AMD GPU with ROCm support (RX 5000+, Radeon VII, etc.)

bash

# Ubuntu/Debian
# Add ROCm repository (see https://rocm.docs.amd.com for latest)
sudo apt install rocm-smi hipcc

# Set environment
export ROCM_PATH=/opt/rocm

# Verify
rocm-smi            # Shows GPU info
hipcc --version     # Shows ROCm version

# Build
./build-gpu.sh

🎯 Advanced Usage

Manual Feature Override

Want to force a specific acceleration method? Use the TAURI_GPU_FEATURE environment variable with the shell scripts:

bash

# Force CUDA (ignore auto-detection)
TAURI_GPU_FEATURE=cuda ./dev-gpu.sh
TAURI_GPU_FEATURE=cuda ./build-gpu.sh

# Force Vulkan
TAURI_GPU_FEATURE=vulkan ./dev-gpu.sh
TAURI_GPU_FEATURE=vulkan ./build-gpu.sh

# Force ROCm (HIPBlas)
TAURI_GPU_FEATURE=hipblas ./dev-gpu.sh
TAURI_GPU_FEATURE=hipblas ./build-gpu.sh

# Force CPU-only (for testing)
TAURI_GPU_FEATURE="" ./dev-gpu.sh
TAURI_GPU_FEATURE="" ./build-gpu.sh

# Force OpenBLAS (CPU-optimized)
TAURI_GPU_FEATURE=openblas ./dev-gpu.sh
TAURI_GPU_FEATURE=openblas ./build-gpu.sh

Build Output Location

After successful build:

text

src-tauri/target/release/bundle/appimage/Meetily_<version>_amd64.AppImage

🧭 Troubleshooting

"CUDA toolkit not found"

Fix: Install nvidia-cuda-toolkit or set CUDA_PATH environment variable
Check: nvcc --version should work

"Vulkan detected but missing dependencies"

Fix: Set both VULKAN_SDK and BLAS_INCLUDE_DIRS environment variables

Example:

bash

export VULKAN_SDK=/usr
export BLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu

"AppImage build stripping symbols"

Fix: Already handled! build-gpu.sh sets NO_STRIP=true automatically
Why: Prevents runtime errors from missing symbols

Build works but no GPU acceleration

Check detection: Look at the build output for GPU detection messages
Verify: nvidia-smi (NVIDIA) or rocm-smi (AMD) should work
Missing SDK: Install the development toolkit, not just drivers

macOS

🍎 Building on macOS

On macOS, the build process is simplified as GPU acceleration (Metal) is enabled by default.

1. Install Dependencies

bash

# Install Homebrew (if not already installed)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install required tools
brew install cmake node pnpm

2. Build and Run

bash

# Development mode (with hot reload)
pnpm tauri:dev

# Production build
pnpm tauri:build

The application will be built with Metal GPU acceleration automatically.

Windows

🪟 Building on Windows

1. Install Dependencies

Node.js: Download and install from nodejs.org.
Rust: Install from rust-lang.org.
Visual Studio Build Tools: Install the "Desktop development with C++" workload from the Visual Studio Installer.
CMake: Download and install from cmake.org.

2. Build and Run

powershell

# Development mode (with hot reload)
pnpm tauri:dev

# Production build
pnpm tauri:build

By default, the application will be built with CPU-only processing. To enable GPU acceleration, see the GPU Acceleration Guide.

File: docs/building_in_linux.md

🐧 Building on Linux

This guide helps you build Meetily on Linux with automatic GPU acceleration. The build system detects your hardware and configures the best performance automatically.

🚀 Quick Start (Recommended for Beginners)

If you're new to building on Linux, start here. These simple commands work for most users:

1. Install Basic Dependencies

bash

# Ubuntu/Debian
sudo apt update
sudo apt install build-essential cmake git

# Fedora/RHEL
sudo dnf install gcc-c++ cmake git

# Arch Linux
sudo pacman -S base-devel cmake git

2. Build and Run

bash

# Development mode (with hot reload)
./dev-gpu.sh

# Production build
./build-gpu.sh

That's it! The scripts automatically detect your GPU and configure acceleration.

What Happens Automatically?

✅ NVIDIA GPU → CUDA acceleration (if toolkit installed)
✅ AMD GPU → ROCm acceleration (if ROCm installed)
✅ No GPU → Optimized CPU mode (still works great!)

💡 Tip: If you have an NVIDIA or AMD GPU but want better performance, jump to the GPU Setup section below.

🧠 Understanding Auto-Detection

The build scripts (dev-gpu.sh and build-gpu.sh) orchestrate the entire build process. They first call scripts/auto-detect-gpu.js to identify your hardware, then build the llama-helper sidecar with the appropriate features, and finally launch the Tauri application.

Detection Priority

Priority	Hardware	What It Checks	Result
1️⃣	NVIDIA CUDA	`nvidia-smi` exists + (`CUDA_PATH` or `nvcc` found)	`--features cuda`
2️⃣	AMD ROCm	`rocm-smi` exists + (`ROCM_PATH` or `hipcc` found)	`--features hipblas`
3️⃣	Vulkan	`vulkaninfo` exists + `VULKAN_SDK` + `BLAS_INCLUDE_DIRS` set	`--features vulkan`
4️⃣	OpenBLAS	`BLAS_INCLUDE_DIRS` set	`--features openblas`
5️⃣	CPU-only	None of the above	(no features, pure CPU)

Common Scenarios

Your System	Auto-Detection Result	Why
Clean Linux install	CPU-only	No GPU SDK detected
NVIDIA GPU + drivers only	CPU-only	CUDA toolkit not installed
NVIDIA GPU + CUDA toolkit	CUDA acceleration ✅	Full detection successful
AMD GPU + ROCm	HIPBlas acceleration ✅	Full detection successful
Vulkan drivers only	CPU-only	Vulkan SDK + env vars needed
Vulkan SDK configured	Vulkan acceleration ✅	All requirements met

💡 Key Insight: Having GPU drivers alone isn't enough. You need the development SDK (CUDA toolkit, ROCm, or Vulkan SDK) for acceleration.

🔧 GPU Setup Guides (Intermediate)

Want better performance? Follow these guides to enable GPU acceleration.

🟢 NVIDIA CUDA Setup

Prerequisites: NVIDIA GPU with compute capability 5.0+ (check: nvidia-smi --query-gpu=compute_cap --format=csv)

Step 1: Install CUDA Toolkit

bash

# Ubuntu/Debian (CUDA 12.x)
sudo apt install nvidia-driver-550 nvidia-cuda-toolkit

# Verify installation
nvidia-smi          # Shows GPU info
nvcc --version      # Shows CUDA version

Step 2: Build with CUDA

bash

# Set your GPU's compute capability
# Example: RTX 3080 = 8.6 → use "86"
# Example: GTX 1080 = 6.1 → use "61"

CMAKE_CUDA_ARCHITECTURES=75 \
CMAKE_CUDA_STANDARD=17 \
CMAKE_POSITION_INDEPENDENT_CODE=ON \
./build-gpu.sh

💡 Finding Your Compute Capability:
bash
nvidia-smi --query-gpu=compute_cap --format=csv
Convert 7.5 → 75, 8.6 → 86, etc.

Why these flags?

CMAKE_CUDA_ARCHITECTURES: Optimizes for your specific GPU
CMAKE_CUDA_STANDARD=17: Ensures C++17 compatibility
CMAKE_POSITION_INDEPENDENT_CODE=ON: Fixes linking issues on modern systems

🔵 Vulkan Setup (Cross-Platform Fallback)

Vulkan works on NVIDIA, AMD, and Intel GPUs. Good choice if CUDA/ROCm don't work.

Step 1: Install Vulkan SDK and BLAS

bash

# Ubuntu/Debian
sudo apt install vulkan-sdk libopenblas-dev

# Fedora
sudo dnf install vulkan-devel openblas-devel

# Arch Linux
sudo pacman -S vulkan-devel openblas

Step 2: Configure Environment

bash

# Add to ~/.bashrc or ~/.zshrc
export VULKAN_SDK=/usr
export BLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu

# Apply changes
source ~/.bashrc

Step 3: Build

bash

./build-gpu.sh

The script will automatically detect Vulkan and build with --features vulkan.

🔴 AMD ROCm Setup (AMD GPUs Only)

Prerequisites: AMD GPU with ROCm support (RX 5000+, Radeon VII, etc.)

bash

# Ubuntu/Debian
# Add ROCm repository (see https://rocm.docs.amd.com for latest)
sudo apt install rocm-smi hipcc

# Set environment
export ROCM_PATH=/opt/rocm

# Verify
rocm-smi            # Shows GPU info
hipcc --version     # Shows ROCm version

# Build
./build-gpu.sh

🎯 Advanced Usage

Manual Feature Override

Want to force a specific acceleration method? Use the TAURI_GPU_FEATURE environment variable with the shell scripts:

bash

# Force CUDA (ignore auto-detection)
TAURI_GPU_FEATURE=cuda ./dev-gpu.sh
TAURI_GPU_FEATURE=cuda ./build-gpu.sh

# Force Vulkan
TAURI_GPU_FEATURE=vulkan ./dev-gpu.sh
TAURI_GPU_FEATURE=vulkan ./build-gpu.sh

# Force ROCm (HIPBlas)
TAURI_GPU_FEATURE=hipblas ./dev-gpu.sh
TAURI_GPU_FEATURE=hipblas ./build-gpu.sh

# Force CPU-only (for testing)
TAURI_GPU_FEATURE="" ./dev-gpu.sh
TAURI_GPU_FEATURE="" ./build-gpu.sh

# Force OpenBLAS (CPU-optimized)
TAURI_GPU_FEATURE=openblas ./dev-gpu.sh
TAURI_GPU_FEATURE=openblas ./build-gpu.sh

Build Output Location

After successful build:

text

src-tauri/target/release/bundle/appimage/Meetily_<version>_amd64.AppImage

🧭 Troubleshooting

"CUDA toolkit not found"

Fix: Install nvidia-cuda-toolkit or set CUDA_PATH environment variable
Check: nvcc --version should work

"Vulkan detected but missing dependencies"

Fix: Set both VULKAN_SDK and BLAS_INCLUDE_DIRS environment variables

Example:

bash

export VULKAN_SDK=/usr
export BLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu

"AppImage build stripping symbols"

Fix: Already handled! build-gpu.sh sets NO_STRIP=true automatically
Why: Prevents runtime errors from missing symbols

Build works but no GPU acceleration

Check detection: Look at the build output for GPU detection messages
Verify: nvidia-smi (NVIDIA) or rocm-smi (AMD) should work
Missing SDK: Install the development toolkit, not just drivers

📊 Technical Reference

Complete Feature Matrix

Mode	Feature Flag	Requirements	Acceleration	Speed Boost
CUDA	`--features cuda`	`nvidia-smi` + (`CUDA_PATH` or `nvcc`)	GPU	5-10x
ROCm	`--features hipblas`	`rocm-smi` + (`ROCM_PATH` or `hipcc`)	GPU	4-8x
Vulkan	`--features vulkan`	`vulkaninfo` + `VULKAN_SDK` + `BLAS_INCLUDE_DIRS`	GPU	3-6x
OpenBLAS	`--features openblas`	`BLAS_INCLUDE_DIRS`	CPU-optimized	1.5-2x
CPU	(none)	(none)	CPU-only	1x (baseline)

Build Scripts Internals

Both dev-gpu.sh and build-gpu.sh work the same way:

Detect location: Find package.json (works from project root or frontend/)
Choose package manager: Prefer pnpm, fallback to npm
Call npm script: Run tauri:dev or tauri:build
Auto-detect GPU: The npm script calls scripts/tauri-auto.js
Feature selection: scripts/auto-detect-gpu.js checks hardware
Build with features: Tauri builds with detected --features flag

Environment Variables Reference

Variable	Purpose	Example
`CUDA_PATH`	CUDA installation directory	`/usr/local/cuda`
`ROCM_PATH`	ROCm installation directory	`/opt/rocm`
`VULKAN_SDK`	Vulkan SDK directory	`/usr`
`BLAS_INCLUDE_DIRS`	BLAS headers location	`/usr/include/x86_64-linux-gnu`
`CMAKE_CUDA_ARCHITECTURES`	GPU compute capability	`75` (for compute 7.5)
`CMAKE_CUDA_STANDARD`	C++ standard for CUDA	`17`
`CMAKE_POSITION_INDEPENDENT_CODE`	Enable PIC for linking	`ON`
`NO_STRIP`	Prevent symbol stripping (AppImage)	`true`

✅ Complete Example Builds

NVIDIA GPU (CUDA)

bash

# Install
sudo apt install nvidia-driver-550 nvidia-cuda-toolkit

# Verify
nvidia-smi --query-gpu=compute_cap --format=csv

# Build (adjust architecture for your GPU)
CMAKE_CUDA_ARCHITECTURES=86 \ # (86 may change in your case)
CMAKE_CUDA_STANDARD=17 \
CMAKE_POSITION_INDEPENDENT_CODE=ON \
./build-gpu.sh

AMD GPU (ROCm)

bash

# Install ROCm (see AMD docs for your distro)
sudo apt install rocm-smi hipcc
export ROCM_PATH=/opt/rocm

# Build
./build-gpu.sh

Any GPU (Vulkan)

bash

# Install
sudo apt install vulkan-sdk libopenblas-dev

# Configure
export VULKAN_SDK=/usr
export BLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu

# Build
./build-gpu.sh

No GPU (CPU-only)

bash

# Just build - works out of the box
./build-gpu.sh

Need help? Open an issue on GitHub with your GPU type, distro, and the output from ./build-gpu.sh.

File: docs/GPU_ACCELERATION.md

GPU Acceleration Guide

Meetily supports GPU acceleration for transcription, which can significantly improve performance. This guide provides detailed information on how to set up and configure GPU acceleration for your system.

Supported Backends

Meetily uses the whisper-rs library, which supports several GPU acceleration backends:

CUDA: For NVIDIA GPUs.
Metal: For Apple Silicon and modern Intel-based Macs.
Core ML: An additional acceleration layer for Apple Silicon.
Vulkan: A cross-platform solution for modern AMD and Intel GPUs.
OpenBLAS: A CPU-based optimization that can provide a significant speed-up over standard CPU processing.

Automatic GPU Detection

The build scripts (dev-gpu.sh, build-gpu.sh) are designed to automatically detect your GPU and enable the appropriate feature flag during the build process. The detection is handled by the scripts/auto-detect-gpu.js script.

Here's the detection priority:

CUDA (NVIDIA)
Metal (Apple)
Vulkan (AMD/Intel)
OpenBLAS (CPU)

If no GPU is detected, the application will fall back to CPU-only processing.

Manual Configuration

If you want to manually configure the GPU acceleration backend, you can do so by enabling the corresponding feature flag in the frontend/src-tauri/Cargo.toml file.

For example, to enable CUDA, you would modify the [features] section as follows:

toml

[features]
default = ["cuda"]

# ... other features

cuda = ["whisper-rs/cuda"]

Then, you would build the application using the standard pnpm tauri:build command.

Platform-Specific Instructions

Linux

For detailed instructions on setting up GPU acceleration on Linux, please refer to the Linux build instructions.

macOS

On macOS, Metal GPU acceleration is enabled by default. No additional configuration is required.

Windows

To enable GPU acceleration on Windows, you will need to install the appropriate toolkit for your GPU (e.g., the CUDA Toolkit for NVIDIA GPUs) and then build the application with the corresponding feature flag enabled.

File: frontend/src-tauri/templates/README.md

Meeting Summary Templates

This directory contains template definitions for meeting summary generation.

Available Templates

1. `daily_standup.json`

Time-boxed daily updates template designed for engineering/product teams.

Sections:

Date
Attendees
Yesterday (completed work)
Today (planned work)
Blockers
Notes

2. `standard_meeting.json`

General-purpose meeting notes template focusing on key outcomes and actions.

Sections:

Summary
Key Decisions
Action Items
Discussion Highlights

Template Structure

Each template JSON file follows this schema:

json

{
  "name": "Template Name",
  "description": "Brief description of the template's purpose",
  "sections": [
    {
      "title": "Section Title",
      "instruction": "Instructions for the LLM on what to extract/include",
      "format": "paragraph|list|string",
      "item_format": "Optional: Markdown table format for list items"
    }
  ]
}

Custom Templates

Users can add custom templates to the application data directory:

macOS: ~/Library/Application Support/Meetily/templates/
Windows: %APPDATA%\Meetily\templates\
Linux: ~/.config/Meetily/templates/

Custom templates override built-in templates with the same filename.

Template Fields

Root Level

name (required): Display name for the template
description (required): Brief explanation of the template's use case
sections (required): Array of section definitions

Section Object

title (required): Section heading text
instruction (required): LLM guidance for this section
format (required): One of "paragraph", "list", or "string"
item_format (optional): Markdown formatting hint for list items (e.g., table structure)
example_item_format (optional): Alternative formatting hint

Usage in Code

Templates are loaded using the templates module:

rust

use crate::summary::templates;

// Get a specific template
let template = templates::get_template("daily_standup")?;

// List available templates
let available = templates::list_templates();

// Validate custom template JSON
let custom_json = std::fs::read_to_string("custom.json")?;
let validated = templates::validate_template(&custom_json)?;

File: frontend/README.md

Meetily - Frontend

A modern desktop application for recording, transcribing, and analyzing meetings with AI assistance. Built with Next.js and Tauri for a native desktop experience.

Features

Real-time audio recording from both microphone and system audio
Live transcription using Whisper ASR (locally running)
Native desktop integration using Tauri
Speaker diarization support
Rich text editor for note-taking
Privacy-focused: All processing happens locally

Prerequisites

For macOS:

Node.js (v18 or later)
Rust (latest stable)
pnpm (v8 or later)
Xcode Command Line Tools

For Windows:

Node.js (v18 or later)
Rust (latest stable)
pnpm (v8 or later)
Visual Studio Build Tools with C++ development tools
Windows 10 or later

Project Structure

text

/frontend
├── src/                   # Next.js frontend code
├── src-tauri/             # Rust backend for Tauri
├── public/                # Static assets
└── package.json           # Project dependencies

Installation

For macOS:

Install prerequisites:

bash

# Install Homebrew if not already installed
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Node.js
brew install node

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

# Install pnpm
npm install pnpm

# Install Xcode Command Line Tools
xcode-select --install

Clone the repository and navigate to the frontend directory:

bash

git clone https://github.com/Zackriya-Solutions/meeting-minutes
cd meeting-minutes/frontend

Install dependencies:
bash
```
pnpm install
```

For Windows:

Install prerequisites:
- Install Node.js (v18 or later)
- Install Rust
- Install pnpm: npm install pnpm
- Install Visual Studio Build Tools with C++ development tools

Clone the repository and navigate to the frontend directory:

cmd

git clone https://github.com/Zackriya-Solutions/meeting-minutes
cd meeting-minutes/frontend

Install dependencies:
cmd
```
pnpm install
```

Running the App

For macOS:

Use the provided script to run the app in development mode:

bash

./clean_run.sh

To build a production version:

bash

./clean_build.sh

You can specify the log level (info, debug, trace):

bash

./clean_run.sh debug

For Windows:

Use the provided script to run the app in development mode:

cmd

clean_run_windows.bat

To build a production version:

cmd

clean_build_windows.bat

You can also use the package scripts directly:

bash

pnpm run tauri:dev
pnpm run tauri:build

Local Transcription

Current Meetily does not require a separate FastAPI service, Docker backend, or manually started whisper-server process. Local transcription is handled by the Rust/Tauri desktop app.

For build and acceleration details, see:

Development

Frontend (Next.js)

The frontend is built with Next.js and Tailwind CSS
Source code is in the src/ directory
To run only the frontend: pnpm run dev

Backend (Tauri)

The Rust backend is in the src-tauri/ directory
Handles audio capture, file system access, transcription, storage, and native integrations
To run only the Tauri development server: pnpm run tauri:dev

Troubleshooting

Common Issues on macOS

If you encounter permission issues with scripts, make them executable:
bash
```
chmod +x clean_run.sh clean_build.sh
```
For microphone access issues, ensure the app has microphone permissions in System Preferences

Common Issues on Windows

If you encounter build errors, ensure Visual Studio Build Tools are properly installed
For audio capture issues, check Windows privacy settings for microphone access
If the app fails to start, try running Command Prompt as administrator

Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Docker & Self-Hosted Deployment Verified OCI

File: README.md Copy Chapter

Introduction Copy Chapter

Why Meetily? Copy Chapter

Features Copy Chapter

Installation Copy Chapter

🪟 **Windows** Copy Section

🍎 **macOS** Copy Section

🐧 **Linux** Copy Section

Key Features in Action Copy Chapter

🎯 Local Transcription Copy Section

📥 Import & Enhance `Beta` Copy Section

🤖 AI-Powered Summaries Copy Section

🔒 Privacy-First Design Copy Section

🌐 Custom OpenAI Endpoint Support Copy Section

🎙️ Professional Audio Mixing Copy Section

⚡ GPU Acceleration Copy Section

System Architecture Copy Chapter

For Developers Copy Chapter

Meetily Pro Copy Chapter

Community Thank-You Offer Copy Section

Key Advantages Over Community Edition: Copy Section

Who is PRO for? Copy Section

Contributing Copy Chapter

License Copy Chapter

Acknowledgments Copy Chapter

Star History Copy Chapter

File: backend/whisper-custom/server/README.md Copy Chapter

whisper.cpp/examples/server

Usage Copy Chapter

request examples Copy Chapter

File: backend/README.md Copy Chapter

Legacy Backend Archive

Current Supported Architecture Copy Chapter

Status of This Directory Copy Chapter

File: docs/architecture.md Copy Chapter

System Architecture

High-Level Architecture Diagram Copy Chapter

Component Details Copy Chapter

Frontend (Next.js) Copy Section

Backend (Rust Core) Copy Section

File: docs/BUILDING.md Copy Chapter

Building Meetily from Source

🐧 Building on Linux Copy Chapter

🚀 Quick Start (Recommended for Beginners) Copy Section

1. Install Basic Dependencies

2. Build and Run

What Happens Automatically? Copy Section

🧠 Understanding Auto-Detection Copy Section

Detection Priority

Common Scenarios

🔧 GPU Setup Guides (Intermediate) Copy Section

🟢 NVIDIA CUDA Setup

Step 1: Install CUDA Toolkit

Step 2: Build with CUDA

🔵 Vulkan Setup (Cross-Platform Fallback)

Step 1: Install Vulkan SDK and BLAS

Step 2: Configure Environment

Step 3: Build

🔴 AMD ROCm Setup (AMD GPUs Only)

🎯 Advanced Usage Copy Section

Manual Feature Override

Build Output Location

🧭 Troubleshooting Copy Section

"CUDA toolkit not found"

"Vulkan detected but missing dependencies"

"AppImage build stripping symbols"

Build works but no GPU acceleration

🍎 Building on macOS Copy Chapter

1. Install Dependencies Copy Section

2. Build and Run Copy Section

🪟 Building on Windows Copy Chapter

1. Install Dependencies Copy Section

2. Build and Run Copy Section

File: docs/building_in_linux.md Copy Chapter

🐧 Building on Linux Copy Chapter

🚀 Quick Start (Recommended for Beginners) Copy Chapter

1. Install Basic Dependencies Copy Section

2. Build and Run Copy Section

What Happens Automatically? Copy Section

File: README.md

Introduction

Why Meetily?

Features

Installation

🪟 Windows

🍎 macOS

🐧 Linux

Key Features in Action

🎯 Local Transcription

📥 Import & Enhance `Beta`

🤖 AI-Powered Summaries

🔒 Privacy-First Design

🌐 Custom OpenAI Endpoint Support

🎙️ Professional Audio Mixing

⚡ GPU Acceleration

System Architecture

For Developers

Meetily Pro

Community Thank-You Offer

Key Advantages Over Community Edition:

Who is PRO for?

Contributing

License

Acknowledgments

Star History

File: backend/whisper-custom/server/README.md

Usage

request examples

File: backend/README.md

Current Supported Architecture

Status of This Directory

File: docs/architecture.md

High-Level Architecture Diagram

Component Details

Frontend (Next.js)

Backend (Rust Core)

File: docs/BUILDING.md

🐧 Building on Linux

🚀 Quick Start (Recommended for Beginners)

What Happens Automatically?

🧠 Understanding Auto-Detection

🔧 GPU Setup Guides (Intermediate)

🎯 Advanced Usage

🧭 Troubleshooting

🍎 Building on macOS

1. Install Dependencies

2. Build and Run

🪟 Building on Windows

1. Install Dependencies

2. Build and Run

File: docs/building_in_linux.md

🐧 Building on Linux

🚀 Quick Start (Recommended for Beginners)

1. Install Basic Dependencies

2. Build and Run

What Happens Automatically?

🧠 Understanding Auto-Detection

Detection Priority

Common Scenarios

🔧 GPU Setup Guides (Intermediate)

🟢 NVIDIA CUDA Setup

🔵 Vulkan Setup (Cross-Platform Fallback)

🔴 AMD ROCm Setup (AMD GPUs Only)

🎯 Advanced Usage

Manual Feature Override

Build Output Location

🧭 Troubleshooting

"CUDA toolkit not found"

"Vulkan detected but missing dependencies"

"AppImage build stripping symbols"

Build works but no GPU acceleration

📊 Technical Reference

Complete Feature Matrix

Build Scripts Internals

Environment Variables Reference

✅ Complete Example Builds

NVIDIA GPU (CUDA)

AMD GPU (ROCm)

Any GPU (Vulkan)