sandboxd is a free, open source build & deployment project written in Go and released under MIT. It has 978 GitHub stars, 69 forks and 14 open issues, and was last pushed 33 hours ago. On this registry it ranks #62 of 84 tracked projects in Build & Deployment, with 5 head-to-head comparisons available. It gained 22 stars over the last 30 tracked days.

What is sandboxd?

sandboxd is an open-source, self-hosted AI app builder that runs a coding agent inside isolated sandboxes on your own server and gives every generated app its own live preview URL, and it is built for developers and teams who want the prompt-to-app workflow of hosted builders without giving up their infrastructure, code, or data.

What it is

sandboxd is the open-source engine behind the prompt-to-app pattern. One HTTP request does three things: it spins up a private, isolated container with its own filesystem and limits, runs an AI coding agent inside that container against your prompt, and hands the finished app a live preview URL. Idle sandboxes sleep and wake on demand, so one ordinary box holds many apps instead of a virtual machine each. It is written in Go under the MIT licence, with 943 stars, 59 forks and 14 open issues at last push on 2026-09-09.

The problem it solves is ownership. The products where you type "build me a todo app" and a working site appears at its own link — Lovable, Bolt, v0, Replit — all run on someone else's infrastructure. sandboxd lives in the developer tools and build-and-deployment space as a self-hosted replacement for that hosted workflow, keeping the infrastructure, the code, and the data on your own server. The underlying stack is deliberately small: one Go program driving Docker, Traefik for URLs, and SQLite for state, with no Kubernetes, no separate database, and no queue.

Key capabilities

  • Prompt-to-app isolation: one HTTP request creates a private container with its own filesystem and limits, runs a coding agent inside it, and returns a live preview URL.
  • API-first design: every action is a /v1 call, so the engine is headless and scriptable, and can be driven from your own product.
  • Optional web console: a pure /v1 client for creating an app, chatting to an agent, watching the live preview, editing files, and reviewing a git diff and push in the browser. The engine runs perfectly headless without it.
  • 80+ curated one-click apps, including Ghost, n8n, Gitea, Grafana, Metabase, Uptime Kuma, Jupyter, and Keycloak, each installed and live at its own URL.
  • Starters for React/Vite, Next.js, and FastAPI scaffolds that boot straight to a live preview.
  • Bring your own repo: import any public Git repo with no credential needed, then let a coding agent work on it.
  • Broad runtime support: any Node, Python, or static-binary app boots as-is; anything else uses your own base image or preset, and idle sandboxes sleep and wake on demand.

Who uses it and how

  • Self-hosters on a single machine, because sleeping and waking idle sandboxes lets one ordinary box carry many apps instead of one VM per app.
  • Product teams embedding generation into their own software, driving /v1 directly with the engine running headless and no console required.
  • Non-coders working from the console, running a Ghost blog, n8n automations, a Gitea git host, Grafana or Metabase dashboards, Uptime Kuma, Jupyter, or Keycloak in one click or one prompt.
  • Developers with existing work, importing a public Git repo and reviewing a git diff and push before shipping.
  • arm64 operators, since it runs natively on amd64 and arm64, including Apple Silicon Macs and arm64 Linux hosts such as AWS Graviton, with every image built from multi-arch bases and no cross-compilation.

Getting started

Install in one line with curl -fsSL https://raw.githubusercontent.com/tastyeffectco/sandboxd/main/install.sh | bash, which needs Docker plus the Compose plugin and git on Linux, with macOS via Docker Desktop supported on a best-effort basis. The installer builds the images, starts the stack with the web console, and prints the console URL and a generated login, with the console at http://console.localhost and the API at http://127.0.0.1:9090; run ./console-login.sh to see the login again.

How it compares

Against Lovable, Bolt, v0, and Replit, the difference is licence and location. Those are hosted services, while sandboxd is MIT-licensed and self-hosted, so the infrastructure, code, and data stay yours rather than living inside a vendor's environment. Self-hosting is free forever, with a managed cloud offered only as an optional extra, so the cost model is your own server instead of a subscription.

When to use it — and when not to

A self-hoster takes on Docker, the Compose plugin, git, Traefik for routing, and SQLite for state — a small stack, but one you run yourself, and Linux is the first-class target since macOS is best-effort through Docker Desktop. There is no 1.0 release yet, the README asks readers to sign up for it, and bring-your-own-repo currently covers public repositories only. Teams that want a fully managed service with no box to operate should look elsewhere, and anyone needing private-repo workflows should wait.

project readme (upstream, from github) — read inline

sandboxd

Open-source, self-hosted AI app builder.
Prompt it and a coding agent builds real apps in isolated sandboxes on your server — each live at a preview URL. You own the infra, code, and data. MIT.

🔥 Trend of the Day on Trendshift

sandboxd • Trend of the Day on Trendshift

Live demo   Get started   Star sandboxd

Docs License: MIT Runs on Docker Release Sponsor


Prompt → a real, running app on your server, at its own URL.
See it in action 👇

Build an app from a prompt in the sandboxd console
1 · Build from a prompt — an agent builds it in an isolated sandbox, live at a preview URL.
Run an existing open-source app (n8n) in sandboxd
2 · Or run an existing app — n8n, Ghost, Grafana… 80+ curated apps, one click.
Drive sandboxd from the API / CLI
3 · Or drive the API — every action is a /v1 call, headless & scriptable.

▶ Try the live demo

Click around a real console with sample data — no install.

📣 Stay in the loop

Self-hosting is MIT and free, forever — git clone and you're done.
Want the 1.0 release + occasional product updates, or a managed cloud so you don't run the box yourself? Two links:

Get 1.0 + release news   sandboxd Cloud waitlist

No spam, one-click unsubscribe, and the cloud is optional — the self-hosted engine is always the full product.


What is sandboxd?

The apps where you type "build me a todo app" and a working site appears at its own link — Lovable, Bolt, v0, Replit. sandboxd is the open-source engine that makes that work, on your own server. One HTTP request and it:

  1. spins up a private, isolated container (its own filesystem + limits),
  2. runs an AI coding agent inside it against your prompt, and
  3. hands the app a live preview URL.

Idle sandboxes sleep and wake on demand, so one ordinary box holds many apps instead of a VM each. Under the hood it's deliberately small: one Go program driving Docker, Traefik for URLs, SQLite for state — no Kubernetes, no separate database, no queue.

Two ways to use it

  • API-first — everything is a /v1 call, so you can build sandboxd into your own product.
  • Optional web console — the fastest, no-code way to use it hands-on: create an app, chat to a coding agent, watch the live preview, edit files, and review a git diff & push — all in a browser. It's a pure /v1 client; the engine runs perfectly headless without it.

New here? Start with the console. Building a product? Drive the API.

What can you run? (a lot — from one console, no code)

The console isn't only for coders. Open it and, in one click or one prompt, you can:

  • 🚀 Run a ready-made open-source app — a Ghost blog, n8n automations, a Gitea git host, Grafana / Metabase dashboards, Uptime Kuma, Jupyter, Keycloak… 80+ curated apps, installed and live at their own URL.
  • 🧩 Start from a starter — a React/Vite, Next.js, or FastAPI scaffold that boots to a live preview; then just chat to shape it.
  • 📥 Bring your own repo — import any public Git repo (no credential needed) and let a coding agent work on it.
  • ✨ Build from scratch — describe an app and watch the agent build it in the live preview, then commit & push.

Ghost n8n Directus Gitea Forgejo Grafana Metabase code-server Jupyter Keycloak PocketBase Uptime Kuma Vikunja Wiki.js Trilium Memos Meilisearch Qdrant Chroma Open WebUI Navidrome Audiobookshelf Calibre-Web Actual Budget Syncthing Prefect marimo Homepage ntfy Gotify linkding Superset

This is just a taste — if it's open-source, you can almost certainly run it.
Any Node, Python, or static-binary app boots as-is; anything else, bring your own base image or preset.

Ways to run an app →  ·  Base image, stacks & presets  ·  Architecture

Dev → prod, never shorter: prompt an app into a sandbox, iterate on a live preview, then self-host it on your own server in one command.

Quick start

Needs Docker + the Compose plugin and git on Linux (macOS via Docker Desktop is best-effort). Runs natively on amd64 and arm64 — including Apple Silicon Macs and arm64 Linux hosts (e.g. AWS Graviton) — every image builds from multi-arch bases with no cross-compilation. Install in one line:

curl -fsSL https://raw.githubusercontent.com/tastyeffectco/sandboxd/main/install.sh | bash

It builds the images, starts the stack with the web console, and prints your console URL + a generated login — no password step. Open it, connect an agent under Settings, create an app, and build. No code needed.

  • Console: http://console.localhost — the installer prints your login; lost it? run ./console-login.sh to see it again anytime
  • API: http://127.0.0.1:9090 (curl http://127.0.0.1:9090/healthz → ok)
  • Headless (no console): run with SANDBOXD_CONSOLE=0 (or --no-console)
  • Upgrade later: run ./upgrade.sh — it backs up your database first, health-checks the new version, and rolls back automatically if it fails (Upgrading). ./upgrade.sh --check shows your version.

Prefer the API? Connect an agent once, create a sandbox, hand it a prompt:

API=http://127.0.0.1:9090
curl -s -XPOST $API/v1/agents/claude-code/api-key -d '{"api_key":"sk-ant-..."}'
ID=$(curl -s -XPOST $API/sandbox -d '{"ports":[3000]}' | sed -E 's/.*"id":"([^"]+)".*/\1/')
curl -s -XPOST $API/v1/sandboxes/$ID/tasks -d '{"prompt":"build a todo app on port 3000","agent":"opencode"}'
# open the result at  http://s-$ID-3000.preview.localhost

Full walkthrough → sandboxd.io/quickstart.

🚀 Deploy to a VPS in one click

sandboxd needs one Linux server with Docker — nothing else. Grab a server below (2 vCPU / 4 GB is plenty to start), paste our cloud-init file at creation, and it installs itself.

Disclosure: we earn a referral commission when you sign up through the provider links below, at no additional cost to you. It helps fund sandboxd's development.

Deploy on Vultr

Then on the new server (or paste deploy/cloud-init.yaml as user-data and skip this):

curl -fsSL https://raw.githubusercontent.com/tastyeffectco/sandboxd/main/deploy/bootstrap.sh | sudo bash

Full per-provider walkthrough: deploy/DEPLOY.md.

What you get

  • Isolated sandboxes — a hardened container per app with a workspace + live preview URL; sleep/wake so idle apps cost nothing.
  • Built-in agents — OpenCode & Claude Code. No credential ever enters a sandbox (a proxy injects it on the wire), and every task is checkpointed & revertible.
  • Runtime presets — React/Vite, Next.js, Node/Express, FastAPI, Worker; boot to a preview and reload after agent edits.
  • Files, Git & secrets — in-browser editor + diffs, commit & push, per-app config/secrets (encrypted, write-only).
  • Snapshots / fork / restore, an activity timeline, per-process logs, and live lifecycle tuning.

Who's it for?

✅ Use it if you run many sandboxes for other people — an AI app-builder, an agent platform, a coding playground, per-user or per-branch preview environments, or team multi-app hosting.

❌ Skip it if you just need one or two containers for yourself — a shell script or docker run is simpler. (Why not just a script?)

Get a public URL — sandboxd Cloud

Out of the box, previews live on .sslip.io or localhost: fine on your network, useless for sharing. sandboxd Cloud gives the server you already run https://you.sandboxd.io (console, API and *.preview.you.sandboxd.io) in one command — no domain, DNS, open ports or certificates, and it works behind NAT, on a laptop, or on a $5 VPS. Your compute and data stay on your machine. $9.99/server/month, 50% off at launch. Prefer your own domain? Production / TLS.

Managed — we run it for you

Don't want to run the server yourself? We'll install, configure, and manage sandboxd on your own box — BYOC (your compute, your data, no lock-in). One-time setup + optional monthly management. See Managed →

Documentation

Full docs live at sandboxd.io:

Building on it from your own agent? AGENTS.md is a copy-pasteable runbook.

Roadmap & community

Beta · 0.x. Container isolation (not VMs), single-server, and API auth off by default — all fine for your own users; tighten before untrusted multi-tenancy. See Hardening. Expect the occasional breaking change before 1.0 — pin a version and update as you go.

⭐ If sandboxd is useful, star it

Stars are how other builders find sandboxd — it's the fastest way to support the project (and it keeps us going). Thank you 🙏

Star History Chart

License

MIT. Use it, ship it, sell what you build on it.

Sponsors

sandboxd is free and MIT-licensed. Sponsors keep it maintained and fund the deploy roadmap — thank you to everyone who chips in.

No sponsors yet — be the first.

Frequently asked questions

Is sandboxd free to use?

sandboxd is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does sandboxd do?

Open-source, self-hosted AI app builder — an agent builds real apps in isolated sandboxes on your own server, each live at a preview URL. Self-host in one comma

What is sandboxd written in?

sandboxd is primarily written in Go. Its source is publicly available at https://github.com/tastyeffectco/sandboxd, and it has 978 GitHub stars.