# How to Run Meetily Locally for Development: Complete Setup Guide

> Easily run Meetily locally for development. Clone the repository, install dependencies, and launch the Tauri server with hot-reload using our complete setup guide.

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

---

**To run Meetily locally for development, clone the Zackriya-Solutions/meetily repository, install Rust and Node.js dependencies, then execute [`./dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./dev-gpu.sh) to auto-detect your GPU and launch the Tauri development server with hot-reload enabled.**

Meetily is a privacy-first AI meeting assistant built as a Tauri desktop application with a **Next.js** frontend and **Rust** backend. Running it locally requires setting up a dual-runtime environment where the web UI communicates with native audio processing and transcription modules. This guide walks you through the exact steps to build and launch the project from source.

## Prerequisites

Before you can run Meetily locally for development, install the following toolchain components:

- **Rust** – Install via `rustup` to compile the native backend
- **Node.js and pnpm** – Required for the Next.js frontend (see the frontend README for specific Node version requirements)
- **CMake and build tools** – Essential for compiling native audio dependencies

Platform-specific requirements vary:

- **macOS**: Install Xcode Command Line Tools and Homebrew (`brew install cmake node pnpm`). Metal GPU acceleration works automatically on Apple Silicon.
- **Windows**: Install Visual Studio Build Tools with the "Desktop development with C++" workload, then install Rust and Node/pnpm separately.
- **Linux**: Install `build-essential`, `cmake`, and your preferred GPU SDK (CUDA, ROCm, or Vulkan development libraries) via your package manager.

## Step-by-Step Installation

Follow these commands to set up your local development environment:

1. **Clone the repository**

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

```

2. **Install JavaScript dependencies**

```bash
pnpm install

```

This command installs all Node modules defined in [`frontend/package.json`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/package.json), including Tauri CLI and Next.js.

3. **Verify Rust installation**

Ensure Rust is available in your PATH:

```bash
rustc --version
cargo --version

```

## Launching the Development Server

Meetily supports both CPU-only and GPU-accelerated transcription. The project includes convenience scripts to handle feature detection automatically.

### CPU or Auto-Detect Mode

Run the development script that automatically detects available GPU hardware or falls back to CPU:

```bash
./dev-gpu.sh

```

This script (located at [`frontend/dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/dev-gpu.sh)) sets the appropriate `TAURI_GPU_FEATURE` environment variable and launches the Tauri dev server.

### Explicit GPU Acceleration

To force a specific GPU backend, set the environment variable before running:

```bash

# For NVIDIA CUDA

TAURI_GPU_FEATURE=cuda ./dev-gpu.sh

# For AMD ROCm

TAURI_GPU_FEATURE=hipblas ./dev-gpu.sh

# For Vulkan (cross-platform)

TAURI_GPU_FEATURE=vulkan ./dev-gpu.sh

```

### Alternative: Direct Tauri Command

You can also launch directly using pnpm:

```bash
pnpm tauri:dev

```

On macOS, use `pnpm tauri:dev:metal` to explicitly enable Metal acceleration.

When the server starts, Tauri opens a native window, launches the Next.js dev server on `localhost:3118`, and establishes the Rust-to-UI communication bridge. Changes to either the Rust code in `frontend/src-tauri/src/` or the React components in `frontend/src/` trigger automatic hot-reload.

## Understanding the Architecture

The repository splits functionality across two runtimes that communicate via Tauri commands:

- **Next.js UI** (`frontend/src/`) – Handles the React interface rendered inside the Tauri webview
- **Rust Core** (`frontend/src-tauri/src/`) – Manages audio capture, SQLite storage, transcription pipelines, and LLM-based summarization

When you invoke a command from the frontend using `invoke('command_name')`, Tauri routes the call to the corresponding Rust function registered in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs). Real-time updates flow back to the UI through Tauri events emitted by the Rust backend.

## Common Development Workflows

### Starting a Recording Session

Trigger recording from your frontend code by calling the Tauri command:

```typescript
import { invoke } from '@tauri-apps/api/core';

await invoke('start_recording', {
  mic_device_name: 'Built-in Microphone',
  system_device_name: 'BlackHole 2ch',  // macOS virtual audio device
  meeting_name: 'Team Stand-up'
});

```

This command is implemented 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) in the `start_recording` function.

### Listening for Transcript Updates

Subscribe to real-time transcription events from the Rust audio pipeline:

```typescript
import { listen } from '@tauri-apps/api/event';

listen<TranscriptUpdate>('transcript-update', (event) => {
  console.log('New words:', event.payload.text);
  // Update React state here
});

```

The Rust backend emits these events from [`frontend/src-tauri/src/audio/pipeline.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/pipeline.rs) using `app.emit("transcript-update", data)`.

### Generating Meeting Summaries

Request AI summarization through the summary engine:

```typescript
await invoke('generate_summary', {
  meeting_id: currentMeeting.id,
  model: 'ollama',  // Options: 'claude', 'groq', 'openai'
});

```

This invokes the logic in [`frontend/src-tauri/src/summary_engine.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary_engine.rs), which orchestrates the LLM interaction.

## Platform-Specific Troubleshooting

### macOS Development

If you encounter permission errors for audio capture, grant microphone permissions to your terminal application in System Settings > Security & Privacy. For GPU acceleration verification, check that `gfx-rs` features are enabled in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml).

### Windows Development

Ensure the MSVC C++ compiler is in your PATH. If the build fails with CMake errors, reinstall Visual Studio Build Tools with the C++ workload selected. GPU acceleration on Windows requires CUDA Toolkit or Vulkan SDK installation and setting `TAURI_GPU_FEATURE` explicitly, as auto-detection may default to CPU.

### Linux Development

Install GPU development libraries before building:

```bash

# Ubuntu/Debian with NVIDIA

sudo apt install nvidia-cuda-toolkit libopenblas-dev

# AMD ROCm

sudo apt install rocm-smi libopenblas-dev

```

The auto-detect script at [`scripts/auto-detect-gpu.js`](https://github.com/Zackriya-Solutions/meetily/blob/main/scripts/auto-detect-gpu.js) runs during the build process to select the optimal feature flag based on available hardware.

## Summary

- **Clone** the repository with `git clone https://github.com/Zackriya-Solutions/meetily.git`
- **Install** Rust, Node/pnpm, and CMake as prerequisites
- **Execute** [`./dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./dev-gpu.sh) to auto-detect GPU and launch the Tauri dev server
- **Develop** using hot-reload for both Rust backend (`frontend/src-tauri/src/`) and Next.js frontend (`frontend/src/`)
- **Invoke** commands like `start_recording` and `generate_summary` to interact with the native Rust modules
- **Build** production bundles using `pnpm tauri:build` or [`./build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./build-gpu.sh) for GPU-enabled releases

## Frequently Asked Questions

### What is the fastest way to run Meetily locally for development?

The fastest method is running [`./dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./dev-gpu.sh) from the repository root after installing dependencies. This script auto-detects your GPU architecture (CUDA, Vulkan, or Metal), sets the correct Cargo features, and launches the Tauri development server in a single command.

### Do I need a GPU to develop Meetily locally?

No. While GPU acceleration improves transcription speed significantly, you can run Meetily locally for development using CPU-only mode. The [`./dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./dev-gpu.sh) script automatically falls back to CPU if no compatible GPU SDK is detected, though transcription will consume more CPU resources.

### How do I enable hot-reload when modifying Rust code?

Tauri's development server automatically hot-reloads both the Next.js frontend and Rust backend. When you save changes to files in `frontend/src-tauri/src/`, the Rust compiler rebuilds the native module and restarts the application process while preserving the dev server connection.

### Where can I find detailed build instructions for my specific operating system?

Refer to [`docs/BUILDING.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/BUILDING.md) in the repository root. This file contains platform-specific instructions for macOS, Windows, and Linux, including GPU setup guides for CUDA, ROCm, and Vulkan configuration. For architecture details, see [`docs/architecture.md`](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md).