AINEWS
Celld reimplements Cloudflare's per user stateful compute primitive as a self hosted Rust daemon, with the S3 bucket replacing the control plane, membership service, and consensus layer.
Celld, Ryan Dahl's v0.1.0 release, ports Cloudflare's Durable Objects pattern off Cloudflare's network and onto machines the operator runs. Each "cell" gets its own SQLite database, its own V8 isolate, and a continuously replicated copy in an S3-compatible bucket. The bucket is the only thing nodes need to agree on, which is why there is no membership service, no placement service, and no consensus layer to operate. Per the denoland/celld README, coordination runs through object-storage compare-and-swap, so a dead node is replaceable without any rebalancing ceremony.
Durable Objects, the Cloudflare primitive Celld reimplements, exists to solve one specific problem: per-request state without a separate database round-trip. The pattern co-locates compute and storage in a single addressable unit, then routes requests to whichever edge has it hot, and Cloudflare runs it as a managed service across a global network. Celld reimplements the same idea as a single binary any team can drop on a Linux host, x86-64 or ARM64. Dahl, who created Node.js and co-founded Deno Land, framed the release in an August 5 X post as "order of magnitude cheaper at scale," though no independent benchmark backs that claim.
The runtime surface mirrors the parts of Cloudflare Workers developers actually touch: fetch, service bindings, JavaScript RPC, Durable Objects, alarms, static assets, streams, and WebSockets. Celld also ships part of the Node.js compatibility layer, so most server-side JavaScript runs without rewrites. Deployment uses esbuild via celld deploy, which consumes the same Wrangler bundles Cloudflare does. Under the hood, the stack is small: V8 for execution, SQLite for cell-local storage, LTX for log-structured replication, S3 for the durable copy, and Tokio for async Rust. Celld is a Rust daemon, not a managed service.
The README assumes the internal listener sits on a private network, with WireGuard or Tailscale as the default route, not a public port. Two knobs do most of the load-shedding work: CELLD_MAX_RESIDENT_CELLS caps how many cells stay hot in memory, and an 80% RSS threshold starts pressure-shedding before the kernel's OOM killer fires. Nodes are replaceable, and celld diagnose enumerates the leases a node currently holds, the only built-in observability surface on day one.
Pull requests on the denoland/celld repository are disabled, and patches go to ry@deno.com as git format-patch attachments; contributors sign a Deno Land Inc. CLA before changes land. That posture reads less like a community project and more like Dahl seeding a reference implementation he intends to maintain on his own terms. The Apache-2.0 license keeps the door open for forks, and Linux x86-64 and ARM64 images already publish to ghcr.io, so the first barrier to a self-hosted install is "have a Linux box," not "wait for an ecosystem."
Cloudflare's hosted Durable Objects run on a global edge with seven years of operational hardening, security review, and regional placement built in. Celld on day one ships a binary a team runs itself, in regions the team chooses, against an S3 bucket the team owns. The falsifier is straightforward: if cross-region state-access latency on commodity object storage proves unacceptable for hot paths, the "any host" portability claim breaks. Celld's portability is real, but it is a pattern drop, not an edge-network replacement.
No independent benchmark against a hosted Durable Objects workload exists yet. Until one lands, the only baseline is the Flavio Copes walkthrough and the project README, and the Register's 2026-08-12 re-report is downstream of those primary sources. The repo went from Ryan Dahl's August 5 X post to a working v0.1.0 in roughly a week, and the next test for DevOps teams is whether the runtime survives a real workload before that v0.1.0 becomes v0.2.