Meetily Deployment Options: Native App, Build-from-Source, and Docker Self-Hosting Explained

Meetily can be deployed in three ways: as a pre-built native desktop application, compiled from source with optional GPU acceleration, or run as a self-hosted Docker stack—all fully self-contained with no external data transmission.

This guide covers every Meetily deployment option based on the official source code in Zackriya-Solutions/meetily. Whether you're an end-user seeking a one-click installer, a developer needing customization, or an enterprise running server infrastructure, you'll find the exact commands, file paths, and configuration steps required.

Native Desktop Application (Pre-Built Binaries)

The simplest Meetily deployment option delivers a complete, ready-to-run Tauri application that bundles the Rust backend, Next.js frontend, Whisper/Parakeet transcription engine, and local LLM integration.

Windows Deployment

Download x64-setup.exe from the latest GitHub release. Run the installer and launch Meetily from the Start Menu. The Tauri runtime registers automatically, and all components execute locally without Docker dependencies.

macOS Deployment

Download meetily_0.4.0_aarch64.dmg (Apple Silicon) or the x64 equivalent. Drag the application to Applications, then open it. Gatekeeper may require approving the developer certificate on first launch.

Linux Limitation

No pre-built binaries are distributed for Linux. You must use the build-from-source option described below.

Key source file: The Tauri entry point in [frontend/src-tauri/src/lib.rs](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) registers all native commands and emits UI events for the transcription pipeline.

Build-from-Source Deployment

Building Meetily from source provides full control over compiler flags, GPU backend selection, and code modifications. This deployment option suits developers integrating Meetily into larger toolchains or requiring custom AI provider configurations.

Prerequisites

• Rust (install via rustup)
• Node.js 14+
• pnpm package manager

Initial Setup

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

CPU-Only Build

./clean_build.sh

This script invokes Cargo with default features, producing a portable binary without GPU dependencies.

GPU-Accelerated Builds

Platform	Command	Backend
macOS	pnpm run tauri:dev:metal	Apple Metal
Windows	pnpm run tauri:dev:cuda	NVIDIA CUDA
Linux	pnpm run tauri:dev:vulkan	Vulkan (AMD/Intel/NVIDIA)

Development Launch

pnpm run tauri:dev

The build system respects --features flags defined in Cargo.toml. GPU-specific crates (cuda, vulkan, metal) are conditionally compiled based on your selected command.

Key source files:

• Build orchestration: frontend/clean_build.sh and frontend/clean_run.sh
• Architecture documentation: docs/architecture.md
• Detailed build guide: docs/BUILDING.md

Self-Hosted Docker Deployment

The Docker deployment option runs Meetily as containerized services, exposing the UI over configurable network ports. This suits teams requiring server-side operation, CI/CD integration, or centralized deployment management.

Container Architecture

Container	Purpose
whisper-server	HTTP API for Whisper/Parakeet transcription models
meeting-app	Web-hosted Tauri UI with audio capture, transcription coordination, and LLM summarization

Interactive Quick-Start

cd backend
./run-docker.sh start

The script prompts for model selection, port configuration, GPU preferences, and database setup.

Non-Interactive Launch

./run-docker.sh start \
   -m large-v3 \
   -g \
   -p 8081 \
   --app-port 5180 \
   -d

Parameter breakdown:

• -m large-v3 — Whisper model variant (any listed in the script's catalog)
• -g — Force GPU mode (requires compatible GPU and Docker NVIDIA/AMD runtime)
• -p 8081 — Whisper server port
• --app-port 5180 — Web UI port
• -d — Detach (background execution)

What the Deployment Script Handles

The [backend/run-docker.sh](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/run-docker.sh) script automates:

1. OS detection — Applies macos Docker profile for Apple systems
2. GPU discovery — Uses nvidia-smi or rocm-smi to select Dockerfile.server-gpu vs. Dockerfile.server-cpu
3. Model management — Checks ./models/ directory, downloads missing models via manage_models download
4. Environment configuration — Sets WHISPER_PORT, APP_PORT, and optional WHISPER_TRANSLATE
5. Database persistence — Creates or imports SQLite database at backend/data/meeting_minutes.db
6. Image building — Invokes backend/build-docker.sh when images are stale
7. Service orchestration — Executes docker compose with selected profile

Key implementation sections in run-docker.sh:

• GPU detection: lines 100–130 (detect_system function)
• Model selection: lines 668–708 (select_model function)
• Database handling: lines 560–620 (find_existing_databases, select_database_setup)

Deployment Comparison and Selection Guide

Factor	Native App	Build-from-Source	Docker Self-Hosted
Setup time	Minutes	Hours (first build)	Minutes
Technical skill	None required	Rust/TypeScript proficiency	Docker familiarity
Customization	None	Full source access	Environment variables, ports
GPU control	Pre-configured	Compile-time selection	Runtime detection
Network exposure	Local only	Local only	Configurable (localhost or LAN)
CI/CD integration	Manual updates	Git-based workflows	Automated container orchestration

Practical Code Examples

Custom Docker Deployment with Turbo Model

cd backend
./run-docker.sh start \
   -m large-v3-turbo \
   -g \
   -p 8082 \
   --app-port 5170 \
   -d

Result:

• Whisper API: http://localhost:8082
• Web interface: http://localhost:5170
• GPU acceleration: Enabled via --gpus all

Linux Vulkan Build from Source

git clone https://github.com/Zackriya-Solutions/meetily.git
cd meetily/frontend
pnpm install
pnpm run tauri:dev:vulkan

Launches Meetily with Vulkan compute backend for AMD/Intel GPU acceleration.

Windows Native Installation Flow

1. Download x64-setup.exe from GitHub Releases
2. Execute installer — Tauri runtime registers automatically
3. Launch Meetily — no Docker, no external services, all local execution

Comprehensive File Reference

Path	Deployment Relevance
[README.md](https://github.com/Zackriya-Solutions/meetily/blob/main/README.md)	Supported platforms, quick-install links
[frontend/src-tauri/src/lib.rs](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs)	Tauri command registration (start_recording, etc.)
[frontend/clean_build.sh](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/clean_build.sh)	Build wrapper for CPU/GPU feature selection
[docs/BUILDING.md](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/BUILDING.md)	Platform-specific compilation instructions
[backend/run-docker.sh](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/run-docker.sh)	Complete Docker orchestration with GPU detection
[docs/architecture.md](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md)	System design and component interaction
[docs/GPU_ACCELERATION.md](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/GPU_ACCELERATION.md)	Backend-specific GPU configuration

Summary

• Native desktop application — Download pre-built binaries for Windows or macOS; zero configuration required
• Build-from-source — Full control via Rust/Cargo with selectable GPU backends (Metal, CUDA, Vulkan)
• Docker self-hosting — Containerized deployment with automatic GPU detection, persistent SQLite storage, and configurable network exposure
• All three Meetily deployment options maintain complete data locality—no cloud services or external API calls

Frequently Asked Questions

Does Meetily require internet access after installation?

No. All Meetily deployment options operate entirely offline. The transcription engine (Whisper/Parakeet), LLM integration, and UI run locally. Internet is only needed for initial downloads or Git cloning.

Can I switch from CPU to GPU without rebuilding?

For Docker deployments, yes—pass the -g flag to run-docker.sh and the script selects the appropriate GPU-enabled image. For native builds, you must recompile with the correct feature flags (metal, cuda, or vulkan) as these are compile-time dependencies in Cargo.toml.

Where is meeting data stored in each deployment mode?

Native and source builds use a SQLite database within the application directory. Docker deployments persist data at backend/data/meeting_minutes.db via bind mount, with interactive options to import existing databases during run-docker.sh initialization.

Is there a cloud-hosted version of Meetily?

No. Per the source code and project philosophy, Meetily is strictly self-hosted. The Docker option exposes services over your own network infrastructure, but no managed SaaS offering exists or is planned.

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