# Tako

> Tako is a self-hosted app deployment and development platform for local HTTPS development, production deploys, routing, TLS, logs, secrets, and framework-aware defaults.

Prefer the Quickstart when the goal is to get an app running quickly.
Use the CLI reference and tako.toml reference for exact command and configuration details.
Use Framework Guides and Presets for framework-specific setup.

## Start Here

- [Homepage](https://tako.sh/): Product overview and the shortest path to the docs.
- [Quickstart](https://tako.sh/docs/quickstart): Fastest path from install to local HTTPS development and first deploy.
- [Docs Intro](https://tako.sh/docs): High-level introduction to what Tako does well and who it is for.

## Core Docs

- [How Tako Works](https://tako.sh/docs/how-tako-works): Architecture, request flow, rolling deploys, TLS, health checks, and scaling.
- [Development](https://tako.sh/docs/development): Local development workflow, HTTPS, DNS, routes, and dev behavior.
- [Deployment](https://tako.sh/docs/deployment): Server setup, deploy flow, scaling, secrets, and production operations.

## Reference

- [CLI Reference](https://tako.sh/docs/cli): Commands, flags, output modes, and examples.
- [tako.toml Reference](https://tako.sh/docs/tako-toml): Complete app configuration reference for routes, builds, secrets, and scaling.
- [Presets](https://tako.sh/docs/presets): Framework preset behavior and how presets merge with runtime defaults.
- [Framework Guides](https://tako.sh/docs/framework-guides): Framework-specific adapter examples for Next.js, Vite, TanStack Start, and fetch handlers.

## Project Links

- [GitHub Repository](https://github.com/lilienblum/tako): Source code, examples, and repository docs.
- [JavaScript SDK on npm](https://www.npmjs.com/package/tako.sh): Package entry for the tako.sh JavaScript and TypeScript SDK.

## Optional

- [How to Deploy a Go Gin, Echo, or Chi App to a VPS Without Docker](https://tako.sh/blog/how-to-deploy-a-go-gin-echo-or-chi-app-to-a-vps-without-docker/): A concrete Go walkthrough: pass Gin, Echo, or Chi to tako.ListenAndServe, then deploy a native binary to a VPS without Docker.
- [How to Deploy a Bun Hono App to a VPS Without Docker](https://tako.sh/blog/how-to-deploy-a-bun-hono-app-to-a-vps-without-docker/): A literal Bun + Hono walkthrough: export app.fetch, run tako init, and ship to a VPS with HTTPS and rolling deploys. No Dockerfile required.
- [Typed WebSocket Channels in TypeScript: Params, Auth, and Reconnects](https://tako.sh/blog/typed-websocket-channels-in-typescript/): Tako channels turn TypeBox params, auth, typed publish payloads, replay, and reconnects into one TypeScript WebSocket model.
- [How to Deploy Next.js to a VPS Without Docker](https://tako.sh/blog/how-to-deploy-nextjs-to-a-vps-without-docker/): A literal walkthrough — provision a $5 VPS, point a domain, and ship a Next.js app to it with tako init + tako deploy. HTTPS and zero-downtime rollouts, no Dockerfile in sight.
- [The Open Source Heroku Alternative for 2026](https://tako.sh/blog/open-source-heroku-alternative-for-2026/): Heroku-shaped DX — one CLI, release commands, review apps, scale-to-zero — on hardware you own. A 2026 tour of the open-source alternatives, and where Tako fits.
- [Deploy TanStack Start to a VPS in Five Minutes](https://tako.sh/blog/deploy-tanstack-start-to-a-vps-in-five-minutes/): A concrete walkthrough: scaffold a TanStack Start app, run tako init and tako deploy, and watch the SSR bundle boot natively on Bun behind Pingora — no Docker, no edge platform.
- [Named Worker Groups for Tako Workflows](https://tako.sh/blog/named-worker-groups-for-tako-workflows/): Tako workflows now support named worker pools, so a slow image job in the media group can't starve auth-critical email or default work.
- [A Self-Hosted Pusher and Ably Alternative: Tako Channels](https://tako.sh/blog/self-hosted-pusher-alternative/): Pusher charges per connection, Ably per minute. Tako Channels ships SSE, WebSockets, and replay into your own server — for whatever your VPS already costs.
- [The Open Source Cloudflare Workers Alternative: Tako on Your Own VPS](https://tako.sh/blog/open-source-cloudflare-workers-alternative/): Same fetch handler model, same scale-to-zero feel — without V8 isolate constraints or per-request billing. Tako on your own VPS, with Cloudflare optional in front.
- [The Release Command: Database Migrations During tako deploy](https://tako.sh/blog/the-release-command-database-migrations-during-deploy/): Tako now runs a one-shot release command on the leader server before the rolling update — the missing primitive for Prisma, Drizzle, and Rails migrations against a shared database.
- [Next.js instrumentation.ts meets initServerRuntime](https://tako.sh/blog/tako-workflows-in-nextjs-via-instrumentation/): Drop a five-line instrumentation.ts into your Next.js app and Tako workflows, signals, and channel publishes light up inside routes and server actions — no ambient globals, no bootstrap glue.
- [Tako vs PM2 + Nginx](https://tako.sh/blog/tako-vs-pm2-and-nginx/): PM2 + Nginx is the quiet default for self-hosted Node — a stack of four tools glued together with shell scripts. Tako collapses it into one CLI.
- [Pause a Workflow Until a Human Clicks Approve](https://tako.sh/blog/pause-a-workflow-until-a-human-clicks-approve/): A walkthrough of step.waitFor + signal — an order-fulfillment workflow that parks for days waiting on admin approval, then resumes exactly where it left off.
- [Tako vs Temporal](https://tako.sh/blog/tako-vs-temporal/): Temporal defined the durable-workflow model for a generation of backends. Tako borrows the shape but runs it embedded in the per-app server — no cluster, no Cassandra, no Elasticsearch.
- [Workflow Workers That Scale to Zero, Then Fail Loudly](https://tako.sh/blog/workflow-workers-scale-to-zero/): Tako's workflow workers spawn on enqueue, exit when idle, and mark the app unhealthy on non-zero exit before claim — so broken imports surface immediately instead of silently queuing.
- [tako typegen and the generated tako.gen.ts](https://tako.sh/blog/typegen-and-the-ambient-tako-global/): Tako generates a project-local tako.gen.ts with typed runtime state and a typed secrets bag — zero ambient globals, zero module augmentation, zero silent typos.
- [Secure Code Execution for AI Agents](https://tako.sh/blog/secure-code-execution-for-ai-agents/): AI agents that run code need two security layers: a V8 sandbox for untrusted execution, and secure secret injection so credentials stay out of the isolate.
- [Tako vs Inngest and Trigger.dev](https://tako.sh/blog/tako-vs-inngest-and-trigger/): Inngest and Trigger.dev gave JavaScript a durable-step model worth copying. Tako ships the same primitives embedded in the server that already runs your app — no separate queue service, no per-run bill.
- [Durable Workflows Are Here](https://tako.sh/blog/durable-workflows-are-here/): Tako now ships a durable workflow engine — step checkpoints, retries, cron, sleep for days, and signal/waitFor — on your own VPS, no external queue service.
- [Stateful Apps on Tako: SQLite, Uploads, and the TAKO_DATA_DIR Contract](https://tako.sh/blog/stateful-apps-sqlite-uploads-tako-data-dir/): TAKO_DATA_DIR is a persistent, per-app directory that survives deploys and rolling restarts — so SQLite, file uploads, and queue data just work on a single VPS without external storage.
- [Tako vs Render, Railway, and Vercel: Bringing the Managed-PaaS Feel to Your Own Boxes](https://tako.sh/blog/tako-vs-render-railway-vercel/): Render, Railway, and Vercel made deploying feel easy. Tako brings that same experience to the VPS you already own — same CLI flow, same scale-to-zero, without the platform bill.
- [The Dev Daemon: Why tako dev Is Just a Client](https://tako.sh/blog/the-dev-daemon-tako-dev-is-just-a-client/): tako dev isn't a watcher script — it's a thin viewer attached to a persistent daemon that owns app processes, logs, routing, and TLS.
- [LAN Mode: Hand Your App to a Phone in Three Seconds](https://tako.sh/blog/lan-mode-hand-your-app-to-a-phone/): Press l in tako dev and your app is reachable from any phone or tablet on your Wi-Fi as myapp.local — real HTTPS, no ngrok, no port forwarding.
- [Durable Channels, Built In](https://tako.sh/blog/durable-channels-built-in/): Tako now ships durable WebSocket and SSE channels with replay, reconnection, and per-channel auth — no Pusher, no Redis, no sidecars.
- [What Happens When You Run tako deploy](https://tako.sh/blog/what-happens-when-you-run-tako-deploy/): The full sequence from command to live traffic — build, upload, swap, drain — in about 10 seconds.
- [The Go SDK Is Here](https://tako.sh/blog/the-go-sdk-is-here/): Tako's Go SDK wraps any http.Handler — Gin, Echo, Chi, or plain net/http — with health checks, secrets, and graceful shutdown in one line.
- [Tako vs Sidekick](https://tako.sh/blog/tako-vs-sidekick/): Sidekick turns a VPS into a Docker-powered mini-PaaS. Tako skips Docker entirely. Here's how the two CLI deploy tools compare.
- [Tako vs Fly.io: The Self-Hosted Edge](https://tako.sh/blog/tako-vs-fly/): Fly.io gives you a beautiful CLI and 30+ regions on their hardware. Tako gives you the same feel on your own boxes. An honest comparison of two takes on the edge.
- [Build a Distributed Web App with Tako and CockroachDB](https://tako.sh/blog/build-a-distributed-web-app-with-tako-and-cockroachdb/): Three VPS boxes, Tako for the app layer, CockroachDB for the data layer — a fully distributed stack running on hardware you own, with no managed plan underneath.
- [Multi-Stage Builds for Monorepos](https://tako.sh/blog/multi-stage-builds-for-monorepos/): How Tako's build stages let you deploy monorepo apps with shared packages — no Docker, no CI pipeline, just TOML.
- [Build Your Own Edge Network on Commodity Hardware](https://tako.sh/blog/build-your-own-edge-network-on-commodity-hardware/): Three $5 VPS boxes in different regions, one tako.toml, and Cloudflare geo-steering. Your own global edge network on hardware you own.
- [Zero-Downtime Deploys Without a Container in Sight](https://tako.sh/blog/zero-downtime-deploys-without-a-container-in-sight/): How Tako rolls out new versions with connection draining, health-checked readiness, and automatic rollback — all with native processes.
- [Your $5 VPS Is More Powerful Than You Think](https://tako.sh/blog/your-5-dollar-vps-is-more-powerful-than-you-think/): A $5 Hetzner box gives you 2 vCPUs, 4 GB RAM, and 20 TB bandwidth. Here's what cloud platforms charge for the same resources — and how Tako bridges the gap.
- [The Fetch Handler Pattern: One Function, Every Runtime](https://tako.sh/blog/the-fetch-handler-pattern/): Why Tako chose the web-standard fetch handler as its universal app interface — and how the same export runs on Bun and Node.
- [Secrets Without .env Files](https://tako.sh/blog/secrets-without-env-files/): How Tako encrypts secrets at rest, injects them via fd 3 at runtime, and generates typed accessors — so plaintext never touches disk.
- [Tako vs Coolify: Dashboard vs CLI](https://tako.sh/blog/tako-vs-coolify/): Coolify gives you a full web UI and manages everything in Docker. Tako gives you a CLI, native processes, and a Pingora proxy. Different tools for different people.
- [One Config, Many Servers](https://tako.sh/blog/one-config-many-servers/): One tako.toml, two environments, three servers across regions — how Tako takes a side project all the way to a real production setup.
- [Scale-to-Zero Without Containers](https://tako.sh/blog/scale-to-zero-without-containers/): How Tako scales apps to zero and cold-starts them on demand — without Docker, containers, or a cloud platform.
- [Tako vs Kamal](https://tako.sh/blog/tako-vs-kamal/): How Tako and Kamal approach self-hosted deployment differently — Docker vs native processes, registries vs SFTP, and what each gets right.
- [Tako vs Dokku: Two Philosophies for Self-Hosted Deployment](https://tako.sh/blog/tako-vs-dokku/): Dokku wraps everything in Docker. Tako runs your app directly. Here's how the two approaches compare — and when each one makes sense.
- [Local Dev with Real HTTPS, Real DNS, and Zero Config](https://tako.sh/blog/local-dev-with-real-https/): Stop fighting localhost:3000 and self-signed cert warnings. Tako dev gives you real HTTPS, real domains, and a local proxy — automatically.
- [Pingora vs Caddy vs Traefik: Why We Built on Cloudflare's Proxy](https://tako.sh/blog/pingora-vs-caddy-vs-traefik/): How we chose Pingora over Caddy and Traefik for Tako's proxy layer — and what it means for performance, memory, and architecture.
- [Why Tako Ships an SDK](https://tako.sh/blog/why-tako-ships-an-sdk/): Most deploy tools stop at infrastructure. Tako's SDK gives your app readiness signaling, secret injection, and runtime abstraction — here's why.
- [Why We Don't Default to Docker (and When You Should Still Use It)](https://tako.sh/blog/why-we-dont-default-to-docker/): Why we skip the Docker rebuild loop — and when containers still make sense.
- [Hello, world](https://tako.sh/blog/hello-world/): Tako is live — a complete platform for running apps on your own servers. Deployment, routing, TLS, secrets, and local dev in a single tool.