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

> Set up the Meetily development environment with Rust, Node.js, and PNPM. Follow our guide to auto-detect your GPU, compile llama-helper, and launch the Tauri app.

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

---

**Setting up the Meetily development environment requires installing the Rust toolchain, Node.js 18+, and PNPM, then running the [`./dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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:

```bash

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

```bash
/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```bash
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/dev-gpu.sh) and [`build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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:

```bash

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

```bash
TAURI_GPU_FEATURE=vulkan ./dev-gpu.sh

```

### macOS Quick Start

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

```bash

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

```powershell

# 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs).
- **Live transcripts**: The audio pipeline in [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.