How to Run Meetily Locally for Testing: Complete Setup Guide for Linux, macOS, and Windows

TLDR: Clone the Zackriya-Solutions/meetily repository, install Rust, Node.js, pnpm, and CMake, then run pnpm install followed by ./frontend/clean_run.sh (Linux/macOS) or pnpm tauri:dev (any platform) to launch the Tauri desktop app in development mode with hot-reload enabled.

Meetily is a self-contained desktop application built with Tauri that combines a Next.js frontend with a Rust core handling audio capture, local transcription, and LLM-powered summaries. Running Meetily locally for testing requires cloning the repository, installing system and project dependencies, and invoking the provided convenience scripts that automatically detect your platform and any available GPU acceleration. This guide walks through the exact commands and source files defined in the Zackriya-Solutions/meetily codebase.

Prerequisites and Architecture Overview

Before building, ensure your system has the required toolchain. According to the Meetily source code, you will need:

• Git (with sub-module support)
• Rust toolchain (via rustup)
• Node.js and pnpm
• CMake and platform-specific C++ build tools
• (Optional) CUDA, ROCm, or Vulkan SDK for GPU acceleration on Linux/Windows

The project architecture splits responsibilities cleanly. The Next.js frontend in frontend/ renders the UI and communicates with the Rust core via Tauri commands. The Rust core in frontend/src-tauri/src/lib.rs hosts the audio engine, local SQLite database, transcription engine, and summary backends.

Clone the Repository

Start by cloning the repo and entering the directory:

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

Some components rely on sub-modules, so ensure your clone is recursive if you plan to inspect the full source.

Linux Local Development Setup

Linux is the primary development platform for Meetily. The recommended workflow uses the provided convenience scripts to handle dependency installation and GPU detection automatically.

GPU-Accelerated Testing

Run the development script that auto-detects your GPU and builds the appropriate llama-helper side-car:

# Install system build tools (Ubuntu/Debian example)

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

# Install JavaScript dependencies

pnpm install

# Launch the app with automatic GPU detection

./frontend/dev-gpu.sh

Under the hood, frontend/dev-gpu.sh executes scripts/auto-detect-gpu.js, compiles the side-car with the matching Cargo feature (cuda, vulkan, hipblas, or none), copies the binary into src-tauri/binaries, and finally runs pnpm tauri:dev. The app opens in a native window with hot-reload enabled.

CPU-Only Testing

To force a CPU-only build on a headless VM or a machine without a GPU SDK, unset the feature flag:

TAURI_GPU_FEATURE= ./frontend/dev-gpu.sh

Debug Logging

For verbose output during testing, use clean_run.sh with a log level argument:

./frontend/clean_run.sh debug

macOS Local Development Setup

On macOS, GPU acceleration requires no extra configuration because Metal and CoreML are enabled automatically by the build system.

Install the prerequisites via Homebrew:

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

Then build and run Meetily locally for testing:

# Development mode with hot-reload

pnpm tauri:dev

# Or create a production bundle

pnpm tauri:build

After a production build, you can open the generated app directly:

open src-tauri/target/release/bundle/macos/Meetily.app

Windows Local Development Setup

Windows builds default to CPU-only inference unless you explicitly configure a GPU SDK.

Install the following prerequisites:

• Node.js from nodejs.org
• Rust via rustup
• Visual Studio Build Tools with the "Desktop development with C++" workload
• CMake from cmake.org

Then run:

# Install npm dependencies

pnpm install

# Start the Tauri development server

pnpm tauri:dev

To enable CUDA or Vulkan acceleration, consult docs/GPU_ACCELERATION.md and export TAURI_GPU_FEATURE before invoking the build command:

$env:TAURI_GPU_FEATURE="cuda"
pnpm tauri:dev

Quick One-Liner for Any Platform

If you already have the system prerequisites installed, you can clone, install, and launch in a single sequence:

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

frontend/clean_run.sh cleans prior build artifacts, installs Node dependencies, builds the Next.js UI, and runs pnpm tauri:dev. Pass info, debug, or trace as an argument to control log verbosity.

Key Source Files for Local Testing

When running Meetily locally for testing, these files control the build and runtime behavior:

• frontend/src-tauri/src/lib.rs — Main Tauri entry point that registers commands used by the Next.js UI.
• frontend/src-tauri/src/audio/pipeline.rs — Core audio mixing, VAD, and routing logic executed during local recording tests.
• frontend/src-tauri/src/whisper_engine/whisper_engine.rs — Local transcription engine that processes captured audio when testing offline.
• frontend/dev-gpu.sh — Convenience script that detects GPU capabilities and builds the llama-helper side-car with the correct feature flags.
• frontend/clean_run.sh — Idempotent launch script that clears caches and starts the dev environment.
• docs/BUILDING.md — Detailed platform-specific build instructions.
• docs/GPU_ACCELERATION.md — Guide to enabling CUDA, Vulkan, or ROCm acceleration.

Summary

• Meetily is a Tauri-based desktop app; running it locally for testing requires the Rust toolchain, Node.js, pnpm, and CMake.
• On Linux, use ./frontend/dev-gpu.sh for automatic GPU detection or ./frontend/clean_run.sh for a clean dev launch.
• On macOS, Metal acceleration is automatic; simply run pnpm tauri:dev or pnpm tauri:build.
• On Windows, start with pnpm tauri:dev for CPU-only testing, and set TAURI_GPU_FEATURE to enable CUDA or Vulkan.
• The frontend/clean_run.sh script provides a cross-platform one-liner when system dependencies are already installed.
• Core testing paths include the audio pipeline in frontend/src-tauri/src/audio/pipeline.rs and the transcription engine in frontend/src-tauri/src/whisper_engine/whisper_engine.rs.

Frequently Asked Questions

What is the fastest way to run Meetily locally for testing?

The fastest way is to clone the repository, run pnpm install, and execute ./frontend/clean_run.sh on Linux or macOS. This single script cleans previous build artifacts, installs Node dependencies, compiles the Next.js frontend, and launches the Tauri app in development mode with hot-reload enabled.

Does Meetily require a GPU to run locally?

No. Meetily defaults to CPU-only inference when no GPU SDK is detected. On macOS, Metal and CoreML are used automatically. On Linux and Windows, you can force a CPU-only build by setting TAURI_GPU_FEATURE= before running the dev script, which is useful for testing in headless virtual machines.

Which script should I use for development on Linux?

Use frontend/dev-gpu.sh when you want automatic GPU feature detection and side-car compilation. Use frontend/clean_run.sh when you want a clean slate or need to specify a log level such as debug or trace. Both scripts ultimately invoke pnpm tauri:dev, but dev-gpu.sh additionally runs scripts/auto-detect-gpu.js to configure the Rust build flags.

How do I test the audio and transcription pipeline during local development?

Local builds expose the full audio pipeline defined in frontend/src-tauri/src/audio/pipeline.rs and the Whisper/Parakeet transcription engine in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. Once the app is running in dev mode, you can start a meeting recording in the UI to verify that audio capture, VAD, and local transcription are functioning without external API dependencies.

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