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

> Explore Meetily deployment options: native app, build from source, or self-hosted Docker. Deploy Meetily your way with full data privacy and control.

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

---

**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](https://github.com/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)](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

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

```

### CPU-Only Build

```bash
./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

```bash
pnpm run tauri:dev

```

The build system respects `--features` flags defined in [`Cargo.toml`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/clean_build.sh) and [`frontend/clean_run.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/clean_run.sh)
- Architecture documentation: [docs/architecture.md](https://github.com/Zackriya-Solutions/meetily/blob/main/docs/architecture.md)
- Detailed build guide: [docs/BUILDING.md](https://github.com/Zackriya-Solutions/meetily/blob/main/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

```bash
cd backend
./run-docker.sh start

```

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

### Non-Interactive Launch

```bash
./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)](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`](https://github.com/Zackriya-Solutions/meetily/blob/main/backend/build-docker.sh) when images are stale
7. **Service orchestration** — Executes `docker compose` with selected profile

**Key implementation sections in [`run-docker.sh`](https://github.com/Zackriya-Solutions/meetily/blob/main/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

```bash
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

```bash
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)](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)](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)](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)](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)](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)](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)](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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.