How to Set Up the Meetily Development Environment: Complete Source Build Guide

Setting up the Meetily development environment requires installing the Rust toolchain, Node.js 18+, and PNPM, then running the ./dev-gpu.sh script to auto-detect your GPU, compile the llama-helper sidecar, and launch the Tauri desktop application.

Meetily is a privacy-first AI meeting assistant developed by Zackriya-Solutions. According to the repository source code, it combines a Rust backend—which handles audio capture, local transcription via Whisper, and LLM summarization—with a Next.js + TypeScript frontend that communicates through Tauri commands and events. To set up the Meetily development environment correctly, you must prepare toolchains for both ecosystems plus any platform-specific GPU SDKs.

Prerequisites

Before cloning the repository, verify that your system has the base toolchains installed.

Rust and Node.js Toolchain

Every platform needs Rust (stable), Node.js version 18 or higher, and PNPM. Install them with the following commands:

# Rust

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

# Node.js 18 and PNPM (Debian/Ubuntu example)

curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs
npm i -g pnpm

On macOS, you can use Homebrew instead:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install cmake node pnpm

On Windows, install Visual Studio Build Tools with the "Desktop development with C++" workload, then install Node.js and Rust from their official installers.

Platform-Specific System Dependencies

• Linux: Install build-essential, cmake, git, and the GPU development SDK (nvidia-cuda-toolkit, ROCm, or Vulkan SDK). Drivers alone are insufficient; the build process needs the SDK headers and libraries.
• macOS: Install cmake via Homebrew. GPU acceleration via Metal works out-of-the-box on Apple Silicon.
• Windows: Install CMake and ensure the Visual Studio C++ toolchain is available. CPU-only builds run by default; see docs/GPU_ACCELERATION.md for CUDA or Vulkan enablement.

Clone the Repository and Install Dependencies

Run the following commands from your terminal to clone the Zackriya-Solutions/meetily repository and install the frontend packages:

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

This installs all Next.js dependencies required by the hybrid Tauri application.

Build Scripts and GPU Auto-Detection

Meetily provides root-level scripts—dev-gpu.sh and build-gpu.sh—that orchestrate compilation. As implemented in the source tree, these scripts perform four tasks:

1. Detect the host operating system (darwin, linux, or Windows).
2. Run scripts/auto-detect-gpu.js to select the best GPU feature flag (CUDA, Vulkan, ROCm, or Metal).
3. Build the llama-helper sidecar binary with the matching Cargo features and copy it into frontend/src-tauri/binaries.
4. Invoke pnpm run tauri:dev (development) or pnpm run tauri:build (production).

You can override GPU detection by setting the environment variable TAURI_GPU_FEATURE before invoking the script.

Development Mode vs Production Mode

• GPU-accelerated development: Use ./dev-gpu.sh for daily coding. It enables hot-reload for the Next.js frontend and rebuilds the Rust backend on change.
• GPU-accelerated production build: Use ./build-gpu.sh to generate a release bundle. On Linux, this produces src-tauri/target/release/bundle/appimage/Meetily_*.AppImage.
• CPU-only fallback: Run TAURI_GPU_FEATURE= ./dev-gpu.sh to force CPU-only inference if no GPU SDK is present.

Platform-Specific Quick Start Guides

Linux GPU Development Setup

For Ubuntu systems with NVIDIA hardware, the full workflow to set up the Meetily development environment is:

# Install system dependencies

sudo apt update
sudo apt install -y build-essential cmake git nvidia-driver-550 nvidia-cuda-toolkit

# Clone and install Node dependencies

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

# Launch GPU-accelerated development

./dev-gpu.sh

If the script detects CUDA correctly, you will see output similar to:

✅ Detected GPU feature: cuda
🦙 Building llama-helper sidecar (debug)... ✅ llama-helper built successfully
🎯 Detecting target triple...   Target: x86_64-unknown-linux-gnu
✅ Copied binary to src-tauri/binaries/llama-helper-x86_64-unknown-linux-gnu
Starting complete Tauri application...

To force Vulkan instead of CUDA, run:

TAURI_GPU_FEATURE=vulkan ./dev-gpu.sh

macOS Quick Start

Apple Silicon users can rely on Metal acceleration without installing extra SDKs:

# Install Homebrew dependencies

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install cmake node pnpm

# Clone and bootstrap

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

# Run development mode (Metal auto-enabled)

./dev-gpu.sh

Windows Quick Start

From a PowerShell prompt:

# 1. Install Visual Studio Build Tools (C++ workload)

# 2. Install Node.js and Rust via official installers

# 3. Clone and install dependencies

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

# 4. Start CPU-only or GPU development

.\dev-gpu.bat

By default, Windows builds use CPU-only inference unless you configure CUDA or Vulkan drivers as documented in the GPU acceleration guide.

Running and Debugging Meetily

Once ./dev-gpu.sh finishes, the Tauri window opens. The frontend communicates with the Rust core through commands registered in frontend/src-tauri/src/lib.rs. Key runtime interactions include:

• Start recording: The UI invokes the start_recording command defined in frontend/src-tauri/src/audio/recording_commands.rs.
• Live transcripts: The audio pipeline in frontend/src-tauri/src/audio/pipeline.rs emits transcript-update events to the UI.
• Summarization: The summary engine in frontend/src-tauri/src/summary/mod.rs sends transcript chunks to the configured LLM endpoint (Ollama, Claude, Groq, OpenRouter, or OpenAI-compatible) and emits summary-ready.
• Persistence: Meeting metadata is stored in a local SQLite database managed by frontend/src-tauri/src/database/mod.rs.

Common Debugging Scenarios

If the application fails to launch, check these items first:

• Enable verbose Rust logging: Run RUST_LOG=debug ./dev-gpu.sh to see backend diagnostics.
• GPU detection failures: Verify that nvcc --version (or the appropriate SDK binary) is in your $PATH. The build prints ⚠️ No specific GPU feature detected when the SDK is missing.
• Missing llama-helper sidecar: If target/debug/ does not contain the binary after compilation, run cargo clean from the src-tauri directory and rerun the script.

Summary

• Meetily is a Tauri-based desktop app combining a Next.js frontend with a Rust backend.
• To set up the Meetily development environment, install Rust, Node.js ≥18, PNPM, and OS-specific build tools.
• Run pnpm install inside the frontend directory, then execute ./dev-gpu.sh from the repository root.
• The build scripts auto-detect your GPU and compile the llama-helper sidecar with the correct Cargo features (CUDA, Vulkan, Metal, or CPU).
• All Tauri commands, audio pipeline logic, transcription, summarization, and database code reside under frontend/src-tauri/src/.

Frequently Asked Questions

Do I need an NVIDIA GPU to develop Meetily?

No. While NVIDIA CUDA is supported for GPU-accelerated transcription in frontend/src-tauri/src/whisper_engine/whisper_engine.rs, the build scripts fall back to CPU-only inference automatically. You can also force CPU mode by clearing TAURI_GPU_FEATURE= before running ./dev-gpu.sh.

Why does the build need GPU SDKs instead of just drivers?

The Rust backend compiles against native GPU libraries. According to the build documentation, the presence of a driver is not sufficient; the linker requires the development headers and libraries provided by the nvidia-cuda-toolkit, ROCm, or Vulkan SDK to build the llama-helper sidecar with the corresponding Cargo feature flag.

How do I switch LLM providers during development?

The summarization engine in frontend/src-tauri/src/summary/mod.rs supports multiple backends including Ollama, Claude, Groq, OpenRouter, and generic OpenAI-compatible endpoints. You can select the provider from the UI; no rebuild is required when switching endpoints.

Where is the project database stored?

Meetily uses a lightweight SQLite database. The schema and CRUD helpers are defined in frontend/src-tauri/src/database/mod.rs. All meeting records, transcripts, and summaries remain stored locally on your machine, aligning with the project's privacy-first design.

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