How to Run Meetily Locally for Development: Complete Setup Guide

To run Meetily locally for development, clone the Zackriya-Solutions/meetily repository, install Rust and Node.js dependencies, then execute ./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

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

2. Install JavaScript dependencies

pnpm install

This command installs all Node modules defined in frontend/package.json, including Tauri CLI and Next.js.

3. Verify Rust installation

Ensure Rust is available in your PATH:

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:

./dev-gpu.sh

This script (located at 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:

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

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

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 in the start_recording function.

Listening for Transcript Updates

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

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 using app.emit("transcript-update", data).

Generating Meeting Summaries

Request AI summarization through the summary engine:

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, 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.

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:

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

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