Fully Native Local Development Stacks
Run services natively on macOS, Windows, and Linux without the overhead of virtualisation. Simple, secure, and blazing fast.
Accelerated Agents
Agents automatically access live logs and database schemas from your running stack. Zero setup.
Native Performance
Services run as native processes at full speed and in a fraction of the RAM of a containerised stack. Postgres in 15 MB, not gigabytes — start instantly, stay light on your laptop.
Docker Compatible
Built-in Docker Engine API means your existing setup works transparently with supported blocks.
Secure by Default
Permissions are defined in a simple grammar once and applied across platforms. Work fast and stay safe.
Truly Cross-Platform
Runs native processes on every platform — no virtualization overhead. The same stack behaves identically on macOS, Windows, and Linux.
Supercache CDN
Stackie-verified packages from approved sources, pre-compiled and served from a global CDN. Complex services install in seconds — no source compilation, no waiting.
Native Packages
Uses each platform's native package managers to install and run services — no Docker images, no containers, no overhead.
Simple & Explicit
Clean YAML format with explicit port and path whitelisting. No hidden magic, no complex networking.
Launch complete development environments with a single command. No configuration. No virtualization.
Firebase alternative
A complete local Supabase environment matching npx supabase start — PostgreSQL, auth, REST API, realtime subscriptions, file storage, and a full dashboard. All services. One command.
Relational DB
A standalone PostgreSQL instance ready to connect. Drop-in replacement for any postgres-backed application.
In-memory cache
A lightweight Redis instance for caching, pub/sub, and sessions. Zero configuration.
MySQL compatible
A MariaDB instance compatible with any MySQL application. Runs on :3307 to coexist with existing MySQL installations.
Included services
Stackie blocks are pre-compiled and served from Supercache, our curated edge network — installs and updates land in seconds, on every platform we support.
The supercache is a curated repository of Stackie's supported blocks, maintained by the Stackie team. Source packages are pre-compiled for every platform we ship for, so a fresh install or an update is a single CDN download — no source build, no waiting for a compile to finish on your laptop.
Compatibility-checked
Every block in the supercache catalogue is built and tested against the current Stackie runtime before it ships. If a version is on the CDN, it works.
Provenance you can verify
Sources come from canonical upstream URLs we publish in each block's YAML, and every artefact is SHA-256 checksum-verified at install time. The CDN is a transparent layer in front of upstream — Stackie falls back to the original source if a checksum ever fails to match.
Pre-compiled per platform
Postgres on a base-model M-series, Mailpit on an arm Linux box, Supabase Studio on Windows — same block, platform-native binary, no source compilation required.
Edge-served, globally
Backed by a global CDN so the install bytes come from the nearest edge, not a single mirror on the other side of the planet. New machine, new stack, ready in seconds.
Platforms
One pull, every platform
$ stackie up -b postgres
↳ pulled from Supercache (4.2 MB)
✓ postgres v18.3 ready in 1.1sStackie services live in megabytes, not gigabytes — but the bigger win is everything else that follows from running native processes instead of a Linux VM.
Once your services are real OS processes — not container guests in a hidden Linux VM — every layer underneath them gets out of the way. The OS schedules them, the filesystem doesn't proxy, your debugger sees them as PIDs, and the kernel reclaims memory the moment they're done with it.
Fans off, battery up
Idle Stackie services idle the way native processes do — the OS schedules them out, the CPU stays low, the fans stay quiet, and the laptop sleeps when you close the lid. No guest kernel running underneath to keep the lights on.
Filesystem at native speed
No VirtioFS, no 9P, no virtualised file boundary between
your code and your services. npm install,
test runs, and migrations move at the speed of your actual
disk — which on a recent SSD is plenty fast.
Debugger attaches to a real PID
Your IDE's "Attach to Process", lldb, perf, Instruments — they all work because the service is just another OS process. No remote-debug protocol over a virtualised network, no fragile sidecar to keep alive.
Cold start in seconds, not minutes
A fresh stack comes up as fast as the binaries can spawn — no VM boot, no daemon warm-up. Restart your machine and your dev environment is back the moment you want it.
A full stack, idle
Energy impact stays in single digits, fans never spin up, lid close goes straight to sleep. The OS schedules your services like the native processes they are.
Define your own stacks from our supported blocks, then run them with the native CLI or your existing Docker workflow.
Declare services, ports, and environment variables in a clean YAML file. Stackie handles native installation, sandboxing, and lifecycle.
my-app:
blocks:
postgres:
vars:
USER: admin
DB: myapp
environment:
POSTGRES_PASSWORD: secret
serves:
PORT: 5432Use the native Stackie CLI for full control, or keep your existing Docker commands — Stackie's built-in Docker API makes both work identically.
Stackie includes a full built-in Docker Engine API, so your existing tools, scripts, and muscle memory work unchanged — with native performance underneath.
Set DOCKER_HOST to point at Stackie and your Docker workflow keeps working. When you
reference a supported image like postgres:15, Stackie maps it to the native block — no VM, no image pull,
just raw performance.
Same commands, native services
docker compose up,
docker ps,
docker logs — your muscle memory
stays intact. Stackie translates supported image references into
native blocks running at bare-metal speed.
GUI tools just work
Container panels in VS Code and JetBrains show your running services, ports, and logs. If it speaks Docker API, it works with Stackie.
Blocks, not containers
Stackie doesn't pull images or build Dockerfiles — it maps supported image aliases to native blocks. Postgres, Redis, MariaDB, and a growing list run as real processes, not emulated containers.
Works with
| Process | CPU | Mem |
|---|---|---|
| postgres | 0.0% | 15.2 MB |
| redis | 0.0% | 4.8 MB |
| api | 0.0% | 2.1 MB |
Stackie's built-in MCP server gives agents live access to your services, data stores, and the daemon itself — turning every running stack into an autonomous development environment.
Agents don't just read your stack — they operate it. Live service logs, database schemas, filesystem access, and daemon control are all exposed over MCP the moment your stack starts. No plugins, no glue code.
Deep stack integration
Logs, schemas, migrations, config — agents see everything your stack knows and act on it autonomously. Diagnose a 500, apply a missing migration, and verify the fix in a single session.
Secure by design
Stackie sandboxes every service, so agents can operate freely within their scope without risking cross-service interference. Full autonomy, strict boundaries.
Zero setup, instant access
Stackie automatically enrolls itself with your local AI agent. Start a stack and your agent already has full MCP access — no manual wiring, no configuration steps.
Works with
Purpose built for local development with cloud native stacks.
| 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) |
| Docker Compose [1] | Supported Blocks | Yes |
| Package Source [2] | Homebrew, npm, pip, and more | Docker Hub images |
| macOS Support | Native | Virtualized (VM) |
| Windows Support | Native | Virtualized (WSL2) |
| Linux Support | Native | Native |
| Admin/Root Required | No | Yes (optional on Linux) |
| Learning Curve | Low (simple YAML) | Medium (many concepts) |
| Network Isolation [4] | Shared (like --network=host) | Multiple options |
| Filesystem Isolation | Platform-specific sandboxes | Containers |
| Best For [6] | Cloud Native, Local development | Kubernetes, Distributed containers |
[1] Stackie ships a Docker Engine API compatibility layer in its daemon, so your existing Docker CLI, compose files, and tooling work natively with Stackie — set DOCKER_HOST and nothing else changes. Only applies to services Stackie already supports.
[2] Stackie uses native package managers (Homebrew, npm, pip, etc.) instead of Docker images. Access your language's ecosystem directly.
[4] Stackie sandboxes share network space for simplicity. Good for local dev, different from Docker's approach.
[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.
Run the one-liner for your platform. Installs to
~/.stackie/bin/
— no admin rights required.
Create a stackie-stack.yml or use your existing docker-compose.yml.
my-app:
blocks:
postgres:
vars:
DB: "myapp"
USER: "myapp"
PASSWORD: "secret"
ports:
PORT: 5432
Use stackie up for native CLI or docker compose up via Stackie's built-in Docker API.
# Native Stackie
$ stackie up
# Docker compatible (built-in Docker API)
$ docker compose upNeed help? Check out the documentation or open an issue.
Stackie makes it quick and easy to run common stacks locally.
Common questions about Stackie's features, compatibility, and use cases.
Stackie runs services as native processes on macOS, Windows, and Linux with minimal RAM overhead (~15MB vs 2-4GB+), uses native package managers instead of Docker images, and leverages platform-specific sandboxing for isolation. It's optimized for local development without the Linux VM overhead.
Yes — your existing Docker workflows just work. See the Docker compatibility docs for setup instructions.
Stackie supports macOS 11+ (Apple Silicon and Intel), Windows 10+ (64-bit), and Linux (Ubuntu 20.04+, Debian, Fedora, Arch, and others) on both ARM64 and x86_64 processors.
Stackie uses platform-specific sandboxing to create isolated environments with explicit port and path whitelisting. See the Sandbox docs for a full breakdown of how isolation and permissions work.
No — Stackie uses its own isolated Homebrew installation to prevent conflicts with your system packages. See the installation docs for details on how Stackie manages its own tooling.
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.