How to Deploy Meetily to a Production Environment: Complete Tauri Build Guide

To deploy Meetily to a production environment, compile the Tauri desktop application for your target platform, bundle the Whisper ggml model into the OS-specific application-support directory, and optionally code-sign the resulting native binary before distribution.

Meetily is a privacy-first AI meeting assistant developed by Zackriya-Solutions that runs entirely as a local desktop application. Built with Tauri, it combines a Next.js 14 frontend with a Rust core that handles audio capture, transcription, and LLM summarization without external backend dependencies. This guide walks you through how to deploy Meetily to a production environment using the exact commands, file paths, and build steps defined in the repository.

Production Architecture Overview

Meetily's production bundle is a native desktop binary that embeds three layers. The Tauri entry point in frontend/src-tauri/src/lib.rs registers commands such as start_recording and configures the application event loop. The Rust core handles platform-specific audio capture in frontend/src-tauri/src/audio/stream.rs, mixes streams and applies voice-activity detection in frontend/src-tauri/src/audio/pipeline.rs, and loads the Whisper ggml model for transcription in frontend/src-tauri/src/whisper_engine/whisper_engine.rs. The Next.js frontend in frontend/src/app/page.tsx listens for Tauri events like transcript-update and summary-ready to render the meeting interface.

Prerequisites and Build Toolchains

Before you run the production build, install the common dependencies and platform-specific SDKs documented in docs/BUILDING.md.

From the repository root, install the Node.js and Rust tooling:

# Install Node.js dependencies

pnpm install

# Install the Tauri CLI if it is not already bundled

cargo install tauri-cli

Platform-specific requirements include:

• macOS – Xcode command-line tools and macOS 13 or later for ScreenCaptureKit support.
• Windows – Visual Studio Build Tools with the "Desktop development with C++" workload.
• Linux – cmake, llvm, libomp, and PulseAudio or ALSA development packages.

Build the Frontend and Tauri Application

The production build compiles the Next.js UI into static assets and then links them into the Rust binary via the Tauri CLI.

Compile Next.js Static Assets

Run the frontend compiler from the repository root:

pnpm run build

This outputs the compiled frontend assets to ./frontend/.next.

Run the Tauri Production Build

With the frontend assets ready, invoke the production Tauri build:

pnpm run tauri:build

The Tauri CLI automatically bundles the static assets and compiled Rust code into a native installer. Final artifacts appear under frontend/src-tauri/target/release/bundle/, such as frontend/src-tauri/target/release/bundle/macos/Meetily.app.

You can also enable GPU acceleration features declared in the root Cargo.toml if your target hardware supports them.

Distribute Whisper Model Files

Meetily requires a local Whisper ggml model at runtime. The application looks for these files in the user’s platform-specific application-support directory:

• macOS – ~/Library/Application Support/Meetily/models/
• Windows – %APPDATA%\Meetily\models\
• Linux – $HOME/.local/share/Meetily/models/

You can ship the model alongside your installer or fetch it with the helper script backend/download-ggml-model.sh. For example, on macOS:

mkdir -p ~/Library/Application\ Support/Meetily/models
curl -L https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin \
  -o ~/Library/Application\ Support/Meetily/models/ggml-base.bin

Code-Sign Your Production Binaries

Signed binaries prevent security warnings and gatekeeper blocks on macOS and Windows.

• macOS – Use codesign with an Apple Developer ID certificate.
• Windows – Use signtool with a standard code-signing certificate.
• Linux – Optionally sign the AppImage or .deb with GPG.

# macOS example

codesign --deep --force --options runtime \
  --sign "Developer ID Application: Your Name (TEAMID)" \
  Meetily.app

Verify the Production Build

Launch the binary in release mode and confirm that audio devices are detected, transcription events fire, and offline LLM summarization works. On macOS:

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

Set RUST_LOG=info to surface internal logs from the Rust core and verify that transcript-update events appear in the console output.

Invoke Recording Commands in Production

The production binary exposes the same Tauri commands as the development build. Because the commands are compiled directly into the native binary in frontend/src-tauri/src/lib.rs, you invoke them from the Next.js frontend exactly as you would during development:

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

// Start a recording session
await invoke('start_recording', {
  mic_device_name: 'Built-in Microphone',
  system_device_name: 'BlackHole 2ch',
  meeting_name: 'Quarter-Q Review'
});

// Listen for live transcript updates
await listen<{
  text: string;
  timestamp: string;
}>('transcript-update', (event) => {
  console.log(`[${event.payload.timestamp}] ${event.payload.text}`);
});

Summary

• Meetily is a Tauri desktop app, so deploying to production means packaging a native binary for macOS, Windows, or Linux rather than provisioning a server.
• Run pnpm run build followed by pnpm run tauri:build to compile the Next.js frontend and Rust core into a single installer.
• Place the Whisper ggml model in the OS-specific application-support directory before launching the app.
• Code-sign the binary on macOS and Windows to prevent security warnings during installation.
• Verify the build by checking for transcript-update and summary-ready events with RUST_LOG=info enabled.

Frequently Asked Questions

Do I need a server to deploy Meetily to a production environment?

No. Meetily is designed as a privacy-first desktop application that runs entirely on the client. The Rust core in frontend/src-tauri/src/lib.rs and the audio pipeline in frontend/src-tauri/src/audio/pipeline.rs handle all transcription and summarization locally, so you only need to distribute the compiled binary and Whisper model files.

Which platforms support a production Meetily build?

The repository supports production builds for macOS, Windows, and Linux. The Rust audio layer includes platform-specific device discovery modules for Windows WASAPI, macOS ScreenCaptureKit, and Linux ALSA or PulseAudio under frontend/src-tauri/src/audio/devices/. Run pnpm run tauri:build on each target OS to generate the correct installer format.

Where does Meetily look for the Whisper transcription model?

At runtime, Meetily expects the ggml model in the user’s application-support directory: ~/Library/Application Support/Meetily/models/ on macOS, %APPDATA%\Meetily\models\ on Windows, and $HOME/.local/share/Meetily/models/ on Linux. You can bundle these files with your installer or use the backend/download-ggml-model.sh script to fetch them.

Can I enable GPU acceleration for the production build?

Yes. The root Cargo.toml declares optional features for GPU acceleration such as cuda and vulkan. If your target machines have compatible hardware, enable the appropriate feature during the Tauri build to speed up Whisper transcription.

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