Local First. Minimal RAM. Maximum Speed.
Alpha Preview • macOS 11+ • Apple Silicon & Intel
Run services natively on macOS without the overhead of Docker Desktop. Simple, secure, and blazing fast.
Minimal RAM Usage
Run services in megabytes, not gigabytes. Postgres uses ~15MB instead of 2GB+. Your Mac stays fast.
Native Performance
No Linux VM overhead. Services run as native macOS processes at full speed. Start instantly, run faster.
Simple & Explicit
Clean YAML format with explicit port and path whitelisting. No hidden magic, no complex networking.
Docker Compatible
Run existing docker-compose.yml files with the mocker CLI. Migrate gradually or keep using Docker workflows.
Secure by Default
macOS Seatbelt sandboxing with explicit port and path permissions. Services can only access what you allow.
Homebrew Integration
Uses Homebrew packages instead of Docker images. Isolated installation at ~/.stackie/homebrew/.
Declare what you need, not how it should work.
name: postgres
package:
id: postgresql
version: "15"
provider: brew
ports:
- 5432
paths:
- path: ~/.stackie/data/postgres
mode: rw
environment:
PGDATA: ~/.stackie/data/postgres
POSTGRES_USER: admin
POSTGRES_PASSWORD: secret
restart: unless-stopped
health_check:
test: ["pg_isready", "-U", "admin"]
interval: 30
timeout: 10
retries: 3Explicit port and path whitelisting with Seatbelt sandboxing
services:
postgres:
image: postgres:15
ports:
- "5432:5432"
volumes:
- pgdata:/var/lib/postgresql/data
environment:
POSTGRES_USER: admin
POSTGRES_PASSWORD: secret
restart: unless-stopped
healthcheck:
test: ["CMD", "pg_isready", "-U", "admin"]
interval: 30s
timeout: 10s
retries: 3
volumes:
pgdata:
Use existing compose files with mocker convert
# Using native stackie CLI
stackie up
# Check running sandboxes
stackie ps
# View logs
stackie logs postgres# Using Docker-compatible mocker CLI
mocker compose up -f docker-compose.yml
# Familiar Docker commands
mocker ps
mocker logs postgres
mocker stop postgresPurpose built for cloud native and local development.
| Feature | Stackie | Docker Desktop |
|---|---|---|
| RAM Usage | ~15MB per service | 2-4GB base + per service |
| Startup Time | Instant (native process) | 5-15s (VM initialization) |
| CPU Performance | Native (no virtualization) | Virtualized (overhead) |
| Compose Support [1] | Yes (via mocker) | Yes |
| Package Source [2] | Homebrew, npm, pip, and more | Docker Hub images |
| macOS Support | Native | Virtualized (VM) |
| Windows Support [3] | Soon (native) | Virtualized (WSL2) |
| Linux Support [3] | Soon (native) | Native |
| Learning Curve | Low (simple YAML) | Medium (many concepts) |
| Network Isolation [4] | Shared (like --network=host) | Full isolation available |
| Filesystem Isolation [5] | Sandbox (Seatbelt) | Full isolation (namespaces) |
| Best For [6] | Cloud Native, Local development | Kubernetes, Distributed containers |
[1] The mocker CLI converts docker-compose.yml files into native stackie-recipe.yml format. Integrate the convert command into your build process to keep docker-compose.yml as your source of truth.
[2] Stackie uses native package managers (Homebrew, npm, pip, etc.) instead of Docker images. Access your language's ecosystem directly.
[3] Stackie's Linux and Windows support are in development. Native implementations planned for both platforms.
[4] Stackie sandboxes share network space for simplicity. Good for local dev, different from Docker's approach.
[5] Stackie uses macOS Seatbelt for path-based access control. Docker uses Linux namespaces for full filesystem isolation.
[6] Stackie excels at cloud-native local development with minimal overhead. Docker is the industry standard for Kubernetes and distributed containerized deployments.
From download to running your first sandbox in under 5 minutes.
Download the DMG, drag Stackie to Applications, and launch it. The daemon starts automatically.
Create a stackie-recipe.yml or use your existing docker-compose.yml.
name: postgres
package:
id: postgresql
version: "15"
provider: brew
ports:
- 5432
Use stackie up for native CLI or mocker compose up for Docker compatibility.
# Native Stackie
$ stackie up
# Docker Compatible
$ mocker compose upNeed help? Check out the documentation or open an issue.
~/.stackie/homebrew/) Watch how Stackie compares to Docker Desktop in real-world usage.
We're creating a comprehensive demo showing:
Installation
From DMG to first sandbox in 2 minutes
Performance
Side-by-side startup time comparison
RAM Monitoring
Activity Monitor showing real usage
Migration
Using existing docker-compose files
In the meantime, try it yourself:
Get Started NowWant to contribute a demo video? Open an issue or submit a pull request!
Common questions about Stackie's features, compatibility, and use cases.
Stackie runs services as native macOS processes with minimal RAM overhead (~15MB vs 2-4GB+), uses native package managers (Homebrew, npm, pip) instead of Docker images, and leverages macOS Seatbelt for sandboxing. It's optimized for local development without the Linux VM overhead.
Yes! Use 'mocker convert' to transform your docker-compose.yml files into native stackie-recipe.yml format. If you want to keep using docker-compose.yml as your source of truth, you can integrate the convert command into your build process to automatically generate recipes.
No. Stackie is currently in Alpha and designed specifically for local development. It excels at cloud-native use cases that don't deploy containers to production. For production deployments, use Docker/Kubernetes.
Currently, Stackie supports macOS 11+ (Big Sur and later) on both Apple Silicon and Intel processors. Native Linux and Windows support are in development and planned for future releases.
Stackie uses macOS Seatbelt (sandbox-exec) to create isolated environments with explicit port and path whitelisting. Services can only bind to declared ports and access specified directories. This provides security without the overhead of full virtualization. Stackie itself is written in Rust for performance and memory safety.
The 'stackie' CLI uses native stackie-recipe.yml format and sandbox-first terminology. The 'mocker' CLI provides Docker Compose compatibility for migration. Both manage the same sandboxes through the stackied daemon—choose based on your workflow preference.
No. Stackie uses an isolated Homebrew installation at ~/.stackie/homebrew/ to prevent conflicts with your system packages. This ensures sandboxes don't interfere with your development environment.
Good eye! This site is based on the excellent Astro landing page template by Markus Hsi-Yang Fritz and Peter Hijma. We customized it for Stackie's needs, but the clean design and performance optimizations are all thanks to their great work.