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

> Learn how to run Meetily locally for testing with our complete setup guide. Easily install dependencies and launch the Tauri desktop app on Linux, macOS, or Windows.

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

---

**TLDR:** Clone the `Zackriya-Solutions/meetily` repository, install Rust, Node.js, pnpm, and CMake, then run `pnpm install` followed by [`./frontend/clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```bash
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:

```bash

# 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/dev-gpu.sh) executes [`scripts/auto-detect-gpu.js`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

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

```

### Debug Logging

For verbose output during testing, use [`clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/clean_run.sh) with a log level argument:

```bash
./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:

```bash
/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:

```bash

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

```bash
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:

```powershell

# Install npm dependencies

pnpm install

# Start the Tauri development server

pnpm tauri:dev

```

To enable **CUDA** or **Vulkan** acceleration, consult [`docs/GPU_ACCELERATION.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/GPU_ACCELERATION.md) and export `TAURI_GPU_FEATURE` before invoking the build command:

```powershell
$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:

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

```

[`frontend/clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/whisper_engine.rs)** — Local transcription engine that processes captured audio when testing offline.
- **[`frontend/dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/clean_run.sh)** — Idempotent launch script that clears caches and starts the dev environment.
- **[`docs/BUILDING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/BUILDING.md)** — Detailed platform-specific build instructions.
- **[`docs/GPU_ACCELERATION.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./frontend/dev-gpu.sh) for automatic GPU detection or [`./frontend/clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) and the transcription engine 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).

## 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/./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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/dev-gpu.sh) when you want automatic GPU feature detection and side-car compilation. Use [`frontend/clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/dev-gpu.sh) additionally runs [`scripts/auto-detect-gpu.js`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) and the Whisper/Parakeet transcription engine 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). 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.