# celld

> Self-hosted, distributed Durable Objects daemon that runs Cloudflare Workers and Durable Objects on your own machines, with each cell backed by SQLite replicated to an S3-compatible bucket you own.

celld is an open-source daemon built by Deno Land Inc. that lets you run Cloudflare Workers and Durable Objects on your own infrastructure. It is licensed under Apache-2.0 and distributed as a 58 MB static binary or Docker container. The project reached v0.1.0 in August 2026 and is actively maintained on GitHub.

## What It Is

celld brings the Durable Objects programming model — a single-threaded named object with its own private SQLite database — to self-hosted fleets. Each "cell" is the equivalent of a Cloudflare Durable Object: it serves HTTP, holds WebSocket connections, sets alarms, and makes outbound connections. The key difference is that your data lives in an S3-compatible bucket you own, and your Workers code runs on machines you control. The JavaScript API is intentionally compatible with the Cloudflare Workers and Durable Objects surface, so existing Wrangler bundles can be deployed without code changes (within the documented compatibility boundary).

## Architecture: Bucket as Coordinator

celld's distributed design eliminates the need for a traditional control plane. There is no membership protocol, no failure detector, and no consensus service. Instead:

- **Ownership via compare-and-swap** — one atomic write to the bucket grants a node ownership of a cell; no shared scheduler is involved.
- **SQLite + LTX replication** — each cell's SQLite database is continuously replicated to the bucket as LTX segments (Litestream's replica format). celld does not acknowledge a write until the data is in the bucket (RPO=0).
- **Stateless nodes** — nodes are replaceable. When a cell moves or wakes, its new owner restores the SQLite database from the bucket and resumes execution.
- **Hibernation** — idle cells are evicted from memory; a hibernated cell costs nearly zero because it is only an object in S3.

The runtime embeds V8 and executes Wrangler bundles. Fleet nodes discover each other through bucket leases; there is no join command or fixed membership list.

## Deployment Model

celld ships as a single binary installable via a curl script or as a Docker image for Linux x86-64 and ARM64. Deploying an application uses `celld deploy` (which requires esbuild for Worker code) against any S3-compatible bucket — AWS S3, Cloudflare R2, or compatible alternatives. Starting a fleet node requires only pointing the binary at the same bucket with `--bucket`, `--listen`, and `--advertise` flags. Peer authentication uses HMAC with a fleet secret stored in the bucket; the peer port should be placed on a private network or encrypted overlay such as WireGuard or Tailscale.

Key operational characteristics documented on the project site:
- ~4 ms to wake a hibernated cell
- ~90 ms durable write latency (region-local bucket)
- ~20 s failover after node loss with zero acknowledged writes lost
- ~1,000 resident cells per 8 GB node at ~4 MB RAM per resident cell
- Stateless request p50/p99 of 0.2/0.3 ms (loopback, M-series laptop)

## Cloudflare Compatibility and Tradeoffs

celld targets compatibility with the Cloudflare Workers and Durable Objects APIs so that existing code runs unchanged within the supported surface. The project publishes a dedicated compatibility page listing supported APIs and a limitations page covering the current deployment boundary. The homepage explicitly notes that self-hosting is not automatically more reliable than a managed service — it makes the failure domain explicit and inspectable (your nodes, your bucket provider, your operational choices) rather than eliminating failure.

## Update: v0.1.0

The latest release is v0.1.0, published on 2026-08-05. The repository was created in April 2025 and has been under active development since. The GitHub repository shows 1,104 stars and 26 forks as of the last crawl. The project notes that conformance tests against the Workers/Durable Objects reference behavior and a deterministic simulation of the distributed protocol under fault injection run before each release. Pull requests are disabled; contributions are accepted as `git format-patch` attachments sent to the maintainer.

## Features
- Self-hosted Durable Objects compatible with Cloudflare Workers API
- Each cell backed by its own private SQLite database
- Continuous SQLite replication to S3-compatible bucket (LTX format)
- RPO=0: no acknowledged writes lost on node failure
- Bucket-as-coordinator: no membership protocol, failure detector, or consensus
- Cell hibernation: inactive cells cost nearly zero (S3 object only)
- ~20s failover after node loss with zero data loss
- ~4ms wake time for hibernated cells
- ~1,000 resident cells per 8 GB node
- Static binary (58 MB) and Docker container (Linux x86-64 and ARM64)
- celld deploy command for Wrangler bundle deployment
- celld diagnose command for fleet health inspection
- HMAC peer authentication with replay protection
- Pressure shedding with configurable resident-cell watermarks
- Compatible with AWS S3, Cloudflare R2, and S3-compatible storage
- Supports Workers, Durable Objects bindings, and static assets
- V8 runtime embedded in the daemon
- WireGuard and Tailscale overlay network support for peer security

## Integrations
Cloudflare R2, AWS S3, S3-compatible object storage, Cloudflare Workers (API compatibility), Wrangler, esbuild, Docker, WireGuard, Tailscale, V8, SQLite, LTX (Litestream replica format), DigitalOcean (example fleet hosting)

## Platforms
LINUX, CLI, API

## Pricing
Open Source

## Version
v0.1.0

## Links
- Website: https://celld.dev
- Documentation: https://celld.dev/docs
- Repository: https://github.com/denoland/celld
- EveryDev.ai: https://www.everydev.ai/tools/celld