# How to Configure Meetily: Complete Setup Guide for Audio Capture, GPU Acceleration, and LLM Integration

> Learn to configure Meetily by setting up audio capture, GPU acceleration, and LLM integration. Follow our complete setup guide for Zackriya-Solutions/meetily.

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

---

**To configure Meetily, install platform-specific prerequisites (Node.js, Rust, and build tools), set up virtual audio devices for system capture, enable GPU acceleration via environment variables or build scripts, and select your LLM provider in the Settings panel.**

Meetily is a self-contained Tauri desktop application that pairs a **Next.js/React UI** with a **Rust core** handling audio capture, VAD-driven transcription, and LLM-based summarization. To configure Meetily effectively, you must properly set up the build environment, audio pipeline, hardware acceleration, and AI provider integration. This guide references the actual implementation in `Zackriya-Solutions/meetily` to ensure accurate configuration steps.

## Prerequisites and Installation

Meetily requires **Node.js ≥ 18**, **pnpm**, **Rust**, and platform-specific build tools. The repository includes automated scripts for GPU detection, but you must first install the base dependencies.

### Linux Setup

Install system build tools, Node.js, and pnpm:

```bash
sudo apt update && sudo apt install build-essential cmake git
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install -y nodejs
npm install -g pnpm

```

Clone the repository and use the GPU auto-detection wrapper:

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

```

For GPU support, optionally install **CUDA** (`nvidia-cuda-toolkit`), **ROCm**, or the **Vulkan SDK** with `libopenblas-dev`.

### macOS Setup

Install dependencies via Homebrew, then run the development server:

```bash
brew install cmake node pnpm
pnpm tauri:dev

```

**Metal and Core ML** are auto-enabled on macOS with no additional configuration required.

### Windows Setup

Install **Visual Studio Build Tools** with the C++ workload, Node.js, and pnpm. Then build or run:

```bash
pnpm tauri:dev    # Development

pnpm tauri:build  # Production

```

For NVIDIA GPUs, install the **CUDA Toolkit**; for AMD/Intel, install the **Vulkan SDK**.

## Audio Device Configuration

Meetily captures **two simultaneous streams**: microphone input and system audio output. The Rust 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) handles ring-buffer mixing, resampling to 48 kHz, and EBU-R128 loudness normalization.

### Virtual Audio Devices

System audio capture requires platform-specific virtual devices:

- **macOS**: Install **BlackHole** (2-channel) to create a virtual output that can be captured as input.
- **Windows**: WASAPI loop-back works out-of-the-box with no extra drivers.
- **Linux**: Use PulseAudio "monitor" sources or ALSA "hw:..." monitors.

Configure these in the UI under **Settings → Audio**, selecting your physical microphone as the *Microphone* device and the virtual loopback (e.g., "BlackHole 2ch") as the *System* device.

### Verifying Audio Input

The Settings panel displays real-time level meters. If you see "zero-audio" warnings, check permissions or verify the virtual device is active. The audio enhancement pipeline applies a high-pass filter and optional **RNNoise** processing before sending audio to the Whisper transcription engine.

## GPU Acceleration Configuration

Meetily can offload Whisper transcription to GPU for real-time performance. The [`scripts/dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/scripts/dev-gpu.sh) and [`scripts/build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/scripts/build-gpu.sh) scripts automatically detect available hardware and set appropriate Cargo feature flags.

### Automatic GPU Detection

Run the wrapper scripts to auto-configure:

```bash
./dev-gpu.sh   # Development with auto-detect

./build-gpu.sh # Production build with auto-detect

```

### Manual Backend Override

Force a specific backend by setting `TAURI_GPU_FEATURE` before invoking the script:

```bash

# Force CUDA for NVIDIA GPUs

TAURI_GPU_FEATURE=cuda ./dev-gpu.sh

# Force Vulkan (cross-platform)

TAURI_GPU_FEATURE=vulkan ./build-gpu.sh

# Disable GPU - force CPU only

TAURI_GPU_FEATURE= ./dev-gpu.sh

```

The feature flags are defined in [`frontend/src-tauri/Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/Cargo.toml):

```toml
[features]
default = ["cuda"]
cuda = ["whisper-rs/cuda"]
vulkan = ["whisper-rs/vulkan"]
openblas = ["whisper-rs/openblas"]

```

## LLM Provider Configuration

Meetily supports multiple LLM providers for meeting summarization, controlled by the `LLMProvider` enum in [`frontend/src-tauri/src/summary/llm_client.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/llm_client.rs). Configure your provider in **Settings → LLM**.

| Provider | Configuration Method | Required Setting |
|----------|---------------------|------------------|
| **Built-in AI** | Local Ollama/llama-cpp | No external key required |
| **Ollama** | Local server endpoint | Endpoint URL (default: `http://localhost:11434`) |
| **OpenAI** | Cloud API | `OPENAI_API_KEY` |
| **Claude** | Anthropic API | `ANTHROPIC_API_KEY` |
| **Groq** | Fast inference cloud | `GROQ_API_KEY` |
| **OpenRouter** | Multi-model marketplace | `OPENROUTER_API_KEY` and optional endpoint |

Set API keys via the UI or export them before launching:

```bash
export OPENAI_API_KEY=sk-xxxxx
pnpm tauri:dev

```

For advanced usage, you can programmatically select providers in Rust:

```rust
// From frontend/src-tauri/src/summary/service.rs
let provider = LLMProvider::from_str("ollama")?;
let model = "gemma:2b".to_string();
let summary = generate_summary(&transcript, &model, &provider, None).await?;

```

## Production Build Configuration

When creating release installers, Tauri requires code-signing keys. Copy the placeholder file and populate real values:

```bash
cp frontend/.env.example frontend/.env

```

Set these variables in `.env` or as CI secrets:

```dotenv
TAURI_SIGNING_PRIVATE_KEY=BASE64_ENCODED_KEY
TAURI_SIGNING_PRIVATE_KEY_PASSWORD=your_password

```

## Running Meetily

| Mode | Command | Description |
|------|---------|-------------|
| **Development** | [`./dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./dev-gpu.sh) (Linux)<br>`pnpm tauri:dev` (macOS/Windows) | Hot-reload with GPU auto-detection |
| **Production** | [`./build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./build-gpu.sh) (Linux)<br>`pnpm tauri:build` (macOS/Windows) | Builds `.AppImage`, `.dmg`, or `.msi` |
| **Debug** | `RUST_LOG=debug ./clean_run.sh` | Verbose logging for troubleshooting |

To start recording programmatically via the Tauri command API:

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

await invoke('start_recording', {
  mic_device_name: 'Built-in Microphone',
  system_device_name: 'BlackHole 2ch',
  meeting_name: 'Team Sync'
});

```

## Summary

- **Install prerequisites**: Node.js 18+, pnpm, Rust, and platform build tools (CUDA/Vulkan optional).
- **Configure audio**: Set up virtual loopback devices (BlackHole on macOS, PulseAudio monitor on Linux) and select them in Settings → Audio.
- **Enable GPU**: Use [`./dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/./dev-gpu.sh) for auto-detection, or set `TAURI_GPU_FEATURE=cuda|vulkan` to force specific backends.
- **Select LLM**: Choose from built-in, Ollama, OpenAI, Claude, Groq, or OpenRouter in Settings → LLM, providing API keys as needed.
- **Build releases**: Configure `TAURI_SIGNING_PRIVATE_KEY` in `frontend/.env` for code-signed installers.

## Frequently Asked Questions

### How do I configure GPU acceleration for Whisper transcription in Meetily?

Meetily automatically detects available GPUs via the [`dev-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/dev-gpu.sh) or [`build-gpu.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/build-gpu.sh) scripts, which set the appropriate Cargo features for CUDA, Vulkan, or OpenBLAS. To force a specific backend, set the environment variable `TAURI_GPU_FEATURE=cuda` (for NVIDIA), `vulkan` (for AMD/Intel), or leave it empty for CPU-only mode, then run the build script.

### What audio devices do I need to configure Meetily for meeting recording?

You must configure two devices: a **microphone** for your voice and a **system audio** device for capturing meeting output. On macOS, install BlackHole to create a virtual audio sink; on Linux, use PulseAudio monitor sources; on Windows, WASAPI loop-back works without extra drivers. Select both devices in **Settings → Audio** and verify levels using the built-in meters.

### How do I switch between different LLM providers in Meetily?

Open **Settings → LLM** in the application UI and select your provider from the dropdown. For cloud providers (OpenAI, Claude, Groq, OpenRouter), enter your API key in the provided field. For local models, ensure Ollama is running on `http://localhost:11434` and select the Ollama provider. The `LLMProvider` enum in [`frontend/src-tauri/src/summary/llm_client.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/summary/llm_client.rs) handles the backend routing based on your selection.

### Why is my system audio not being captured after configuring Meetily?

If the UI shows "zero-audio" warnings for the system device, verify that your virtual audio device (BlackHole on macOS or PulseAudio monitor on Linux) is active and set as the default output in your system sound settings. Ensure Meetily has permission to access the device, and check that the selected device name in **Settings → Audio** matches the virtual device exactly.