celld: An Open-Source Implementation of Cloudflare Durable Objects for Self-Hosting

Forum topic · ✨步子哥 · 2026-08-07

Summary

celld is an open-source daemon from the Deno team that brings the Cloudflare Workers + Durable Objects programming model out of Cloudflare's infrastructure. Instead of a control plane or consensus protocol, celld uses an S3-compatible bucket as the sole coordinator: each Durable Object (cell) is a SQLite database, ownership leases are acquired via compare-and-swap atomic writes on bucket objects, and LTX segments continuously replicate cell state to the bucket. Nodes are stateless and replaceable. Benchmark figures from celld.dev show roughly 90 ms persistent write latency, RPO of 0, ~94k stateless req/s per worker thread, 4 ms wake for hibernated cells, ~4 MB per resident cell, and ~20-second failover with zero loss. A cost table indicates that at 10 cells Cloudflare Durable Objects is cheaper, but from 100 cells upward celld becomes dramatically cheaper, reaching roughly 85x lower cost at 100,000 resident cells. Pressure-shedding evicts idle cells at high water marks and lets other nodes re-acquire them, turning out-of-memory into a reversible scheduling decision. The trade-off is a hard dependency on the reliability of the chosen S3-compatible storage.

Overview

celld is an open-source daemon from the Deno team that ports the Cloudflare Workers + Durable Objects programming model out of Cloudflare's infrastructure, letting developers run the same code on their own machines backed by their own S3-compatible storage.

Key points

Bucket as the only coordinator. There is no control plane, no consensus service, and no membership protocol. Each cell (Durable Object) is a SQLite database. Nodes acquire an ownership lease for a cell via compare-and-swap atomic writes against the bucket, so only one node owns a cell at any time without requiring Raft/Paxos. State is continuously replicated to the bucket as LTX segments, and a replacement node can resume a failed cell by re-acquiring the lease and restoring SQLite from the bucket.
Git-like architecture. The bucket is the source of truth; nodes are interchangeable runtimes, similar to how a .git directory holds repository truth while working copies are ephemeral.
Performance benchmarks (from celld.dev).
Persistent write latency (region-local): ~90 ms
RPO: 0
Stateless p50 / p99: 0.2 ms / 0.3 ms
Stateless throughput per worker thread: ~94k req/s
Hibernated cell wake: ~4 ms
Memory per resident cell: ~4 MB (~1,000 cells per 8 GB node)
Cost for inactive cells: ~0
Node failover: ~20 seconds, zero data loss
Cost comparison vs Cloudflare Durable Objects.
10 resident cells: Cloudflare DO ~$42/mo vs celld ~$49/mo
100 cells: $415/mo vs $49/mo
1,000 cells: $4,150/mo vs $49/mo
10,000 cells: $41,500/mo vs $486/mo
100,000 cells: $415,000/mo vs $4,856/mo
The crossover is around 100 cells; above that, celld is roughly 85x cheaper because celld bills per VM while Cloudflare bills per resident-cell-month.
Pressure shedding. When memory or CPU pressure crosses CELLD_MAX_RESIDENT_CELLS (high-water) and CELLD_RESIDENT_LOW_WATER (low-water), the node persists, fences, and releases idle cells as unowned, then refuses to acquire new ones until below low-water. Cells with active work or live WebSockets are not shed. Because state is already in the bucket, shedding is a reversible scheduling decision rather than a failure, in contrast with conventional database OOM behavior.
Why the Deno team built it. Deno already combines V8 and Rust, and celld extends that stack. Where Deno Deploy competes as a managed Cloudflare Workers alternative, celld is the self-hosted counterpart, reflecting a broader demand for open-source PaaS with portable programming models.
Hidden assumption. celld's reliability is bounded by the chosen S3-compatible storage. AWS S3 provides 11 nines of durability, but a self-hosted MinIO cluster inherits its own SLO. Cloudflare Durable Objects avoids this dependency by colocating storage and compute; celld externalizes that trust to the bucket provider.

Bottom line

celld open-sources the Durable Objects programming model: bucket as coordinator, SQLite as state, V8 as runtime, with up to ~85x cost advantage at 100,000 resident cells.