Harbor

Container Desktop for macOS with built-in Chaos Engineering

Harbor is a native macOS application for Docker container management with integrated chaos engineering capabilities. Inject faults, measure impact, and validate resilience - all through a beautiful UI with real-time metrics visualization.

Free Forever - Harbor Core is and will always be completely free. See our licensing model for details.

Why Harbor?

• Native macOS Experience: Built with Tauri, feels like a native app
• Chaos Engineering Built-in: 13 fault types for comprehensive resilience testing
• AI-Powered: 102 MCP tools for Claude integration
• No Kubernetes Required: Works directly with Docker containers
• Open Ecosystem: Build and share plugins, extensions, and integrations

Quick Start

Prerequisites

System Requirements:

• macOS 13.0 or later

Container Runtime (required):

Harbor uses Colima as its container runtime. Install with Homebrew:

brew install colima docker docker-compose

Then start Colima:

colima start

Secure Tunnels (optional):

For exposing containers to the internet via Cloudflare Tunnel:

brew install cloudflared

HTTP Load Testing (optional):

For running load tests against your services:

brew install hey

Note: Harbor does NOT bundle these dependencies. They must be installed separately before using Harbor.

For Development (building from source):

• Node.js 18+ with pnpm
• Rust

Installation

From Release (Recommended)

# Download the latest DMG from releases
open Harbor.dmg
# Drag Harbor to Applications

From Source

git clone https://github.com/rixmerz/harbor.git
cd harbor
pnpm install
pnpm tauri dev

Build for Production

pnpm tauri build
# Output: src-tauri/target/release/bundle/dmg/Harbor.dmg

Features

Container Management

• List, start, stop, remove containers
• View logs in real-time
• Execute commands in containers
• Compose project support

Chaos Engineering (13 Fault Types)

Category	Fault Types
CPU	Throttle, Ramp, Stress
Memory	Ramp, OOM Trigger
Network	Latency, Packet Loss, Jitter, Partition, DNS Failure
Disk	I/O Latency, Throughput Throttle
Process	Kill (SIGKILL/SIGTERM/SIGINT), Freeze

Orchestration

• Fault scheduling and chaining
• Global kill switch for emergency stops
• Scenario versioning and rollback
• Container groups for multi-container experiments

Real-time Observability

• Live metrics dashboard (CPU, Memory, Network, Disk I/O)
• Baseline capture and comparison
• Degradation detection and threshold alerts
• Unified event timeline

Export & Share

• Export metrics to CSV, JSON
• Generate markdown reports
• Shareable scenario bundles
• Audit log for accountability

Secure Tunnels

• Expose containers to internet via Cloudflare Tunnel
• Auto-detect container ports
• Persistent tunnel state across sessions
• Quick anonymous URLs (trycloudflare.com)

HTTP Load Testing

• Run concurrent HTTP requests against endpoints
• Measure latency percentiles (p50, p95, p99)
• Track requests per second (RPS)
• Support for GET, POST, PUT, DELETE, PATCH
• Custom headers and request bodies

AI Integration (MCP)

Harbor includes 102 MCP tools for integration with Claude Desktop:

{
  "harbor": {
    "command": "uv",
    "args": ["run", "--directory", "/path/to/harbor/.mcp", "python", "server.py"]
  }
}

Add this to your Claude Desktop MCP configuration for natural language container management.

Plugin & Extension System

Harbor supports an open plugin ecosystem. Developers can create extensions that integrate with Harbor through public APIs without modifying the core software.

Plugin Capabilities

• Custom fault injection types
• Additional container runtimes
• Third-party observability integrations
• Custom export formats
• Theme and UI customizations

Marketplace

The Harbor Marketplace provides a platform for discovering and distributing plugins:

• Free Plugins: Community-contributed extensions
• Premium Plugins: Commercial plugins with advanced features
• Revenue Sharing: Plugin developers can monetize their work

Note: The Core Software remains free. The Marketplace enables an ecosystem where developers can build and optionally monetize independent extensions.

Building Plugins

// Example plugin structure
export default {
  name: "my-harbor-plugin",
  version: "1.0.0",
  hooks: {
    onFaultInject: async (fault) => { /* custom logic */ },
    onMetricsCapture: async (metrics) => { /* custom logic */ }
  }
}

See Plugin Development Guide for detailed documentation.

Configuration

Harbor stores configuration in ~/.harbor/:

• config.toml - Application settings
• data/ - Scenarios, baselines, and exports
• plugins/ - Installed plugins

Safety Features

• Kill Switch: Emergency stop for all active faults
• Safety Limits: Configurable CPU/memory thresholds
• Watchdog: Automatic cleanup of stale faults
• Audit Log: Track all actions for accountability

Documentation

• User Guide - Getting started and usage
• MCP Tools Reference - Complete list of AI tools
• Architecture - Technical overview
• Plugin Development - Build extensions for Harbor

Architecture

harbor/
├── src/                    # React frontend
│   ├── components/
│   │   ├── simulator/      # Fault injection UI
│   │   ├── visualization/  # Charts and graphs
│   │   └── settings/       # Configuration panel
│   └── services/           # Tauri IPC services
├── src-tauri/              # Rust backend
│   ├── src/
│   │   ├── commands/       # Tauri commands (118 total)
│   │   ├── simulator/      # Core simulation logic
│   │   ├── config/         # Persistent configuration
│   │   └── docker/         # Docker integration
│   └── Cargo.toml
├── .mcp/                   # MCP server (92 tools)
└── plugins/                # Plugin system

Tech Stack

• Frontend: React 19, TypeScript, Recharts, Lucide Icons
• Backend: Rust, Tauri 2.0
• Container Runtime: Docker (via bollard crate)
• Build: Vite, pnpm

Comparison

Feature	Harbor	Chaos Monkey	Litmus	Pumba
Desktop UI	Yes	No	No	No
Real-time Metrics	Yes	No	Limited	No
AI Integration	Yes	No	No	No
No K8s Required	Yes	No	No	Yes
Custom Scenarios	Yes	Limited	Yes	Limited
Network Faults	Yes	No	Yes	Yes
Kill Switch	Yes	No	No	No
Plugin System	Yes	No	Yes	No

Development

# Run with hot reload
pnpm tauri dev

# Type checking
pnpm tsc --noEmit

# Run tests
pnpm test

# Build release
./scripts/build-release.sh

Contributing

Contributions are welcome! Please read our contributing guidelines before submitting PRs.

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Submit a pull request

License & Ecosystem

Harbor is released under the Rixmerz License (RXL) v1.1 - see LICENSE for details.

Key Points

Aspect	Policy
Core Software	Always free, forever
Modifications	Must remain free (copyleft)
Plugins/Extensions	Can be free or commercial
Marketplace	Commissions and revenue sharing allowed

What This Means

• Users: Harbor Core is free. No paywalls, no premium tiers, no subscriptions for core features.
• Developers: You can build commercial plugins and sell them. The Marketplace enables monetization without compromising the free core.
• Community: The essential tool belongs to everyone. The ecosystem can thrive around it.

"The Core belongs to everyone. The ecosystem may thrive freely around it. What is essential stays free forever."

---

Harbor - Built for developers who want to understand how their containers behave under stress.

Copyright (c) 2026 Rixmerz