Deno Is Joining Cloudflare: The Runtime Sunsets, the Big Idea Doesn't

Deno is joining Cloudflare, and this is not a story about one runtime losing to another. It is a bet by two teams that the programming model, not the runtime, is the product: Workers and Durable Objects, run on Cloudflare's network or on your own servers.

On October 9, 2026, the entire Deno team announced the move. Deno Deploy shuts down in six months, Deno's own development of its runtime ends after one more year, and Ryan Dahl and co-founder Bert Belder will merge Deno's celld project into Cloudflare's workerd so Workers apps can be self-hosted with first-class support.

Dahl's own story shows why. When he introduced Node.js in a Berlin warehouse, the demo was a 500-line IRC server that ran on one machine, in one thread, and that has bothered him ever since. The answer he found was Cloudflare's Durable Objects, which build the splitting of work across machines into the programming model itself.

The rest of this post tests the bet: what changed, why both sides wanted it, what could go wrong, and what to do now.

What was announced, and what it means for you

Deno Deploy has the shortest runway, the runtime has a year, and the satellite products are a question mark.

Cloudflare's post does not spell out the runtime's fate; it points readers to Deno's announcement. Silence on the last row is an open question, not good news.

How we got here: four steps from Node.js to celld

Each step in Dahl's career went after a bigger piece of what developers assemble for themselves, which is how a builder of runtimes ended up arguing for a programming model.

1. Node.js. The IRC demo showed what a purely asynchronous model could do. Dropping synchronous networking made servers easy that once needed much more machinery.

2. Deno. Dahl started it to hunt for more powerful abstractions in the same spirit. Deno improved how JavaScript is written, shipped and secured, and grew strong Node.js compatibility. But as Dahl puts it, it never fundamentally changed what you had to build around the runtime: distributing compute, coordinating state, storing data and autoscaling.

3. Deno Deploy. The hosted service made running an app simpler for users. Operating it showed Dahl how much complexity sat underneath: several public clouds, several databases and deeply entangled services.

4. celld. Released in August 2026, it is a self-hostable take on the Workers programming model. It ships as one Rust binary with object storage as its only external service. You run many celld instances and one storage bucket.

The idea that tied step four together came from Durable Objects. Think of each object as a tiny server you address by name, with its own SQL database, single-threaded JavaScript and WebSockets. Give every IRC channel its own object and you have sharded your data and your connections by construction, so spreading work across machines is part of the programming model from day one rather than a project each team assembles later.

Why Cloudflare wanted this: the escape hatch it never finished building

Cloudflare wanted the one thing it had not managed to build itself: a self-hosted Durable Objects implementation that actually scales.

Start with the criticism Cloudflare knows it faces. A popular theory says Workers is deliberately different from other clouds to lock customers in, and that apps built on Durable Objects are architected so differently that leaving becomes impractical. Under that theory, celld, an open-source implementation of Workers and Durable Objects that lets apps move elsewhere, should have worried Cloudflare.

Kenton Varda's reply in the joint post is that the theory is wrong, and he makes two arguments:

• Different because better. Workers' design makes running an app in hundreds of locations cheap and simple, and its bindings make access to outside resources easier and more secure at once. Cloudflare argues you cannot get those benefits while staying compatible with every other platform.

• Lock-in hurts Cloudflare. When it pitched Workers for Platforms in 2022, customers such as Shopify said they could not build on it unless the runtime was open source. So Cloudflare open-sourced workerd, which Varda says is the same code it runs in production. Some former customers have left using it, and he says the escape hatch is good business.

Then comes the admission. Few people run workerd in production, and Cloudflare never built the ecosystem of services and tooling around it that would make that practical. The biggest hole is Durable Objects. Workerd supports them only as a single instance, fine for local testing but unable to scale. Cloudflare's production version is a different beast, built for hundreds of locations and leaning on services run by a team of reliability engineers. No self-hoster wants that. Varda says the TODO comments go back to the first release, and that his own attempt last spring did not work.

That is why celld landed so well. It was built to be fully compatible with Cloudflare's own while staying self-hostable and scalable. In Varda's words, "Deno Land was building it for us!" The Deno team also brings something Cloudflare says it never cracked: a good developer experience around a runtime you operate yourself.

The commercial logic follows. For large customers, a credible way out is a reason to sign in the first place, and a Durable Objects model you can run anywhere is the strongest version of that promise.

Why Deno joined: bigger problems than a runtime can solve

Deno was running a runtime, a hosting service and a self-hostable Workers implementation, and only the last pointed at the problem Dahl cares about.

Operating Deno Deploy, Dahl wrote, showed how much complexity sat beneath its friendly surface, which led him to celld. He also told The New Stack that Deploy was built toward the same ideals as Workers, so joining forces made sense.

The runtime is the harder part to read. Dahl says Deno's growing Node.js compatibility had left it maintaining effectively another implementation of the same technology. It remains MIT-licensed, he notes, but there are "bigger problems that can be solved with a distributed programming model." Deno's post puts it as focus: future work goes into the shared platform, not a separate runtime and hosting service.

The history makes the move look inevitable in hindsight. When Deno raised a $21 million Series A in 2022, TechCrunch reported that Dahl saw Cloudflare Workers as Deploy's closest competitor. There was friction too: in 2021, according to The New Stack, Cloudflare mistakenly blocked Deno's website and module registry, which forced Deno to move infrastructure elsewhere. Yet they also worked together on runtime-interoperability standards at the W3C, alongside Node.js contributors.

When celld arrived in August, its website credited Kenton Varda and the Workers team and described the project as a tribute to their design, as The New Stack reports. Some commentators read celld as both a product and a pitch to Cloudflare.

The hard questions

The announcement says what happens, but four open questions will decide whether it works.

Who carries the runtime after year one? Deno's team welcomes others who want to continue it. But the project has leaned on a full-time team of engineers; TechCrunch described one in 2022, working on bugs and releases. That team is now building something else. A community fork could emerge, though nothing in the announcement promises one.

Can the merged project deliver where Cloudflare's own attempt stalled? Dahl's design is deliberately lean, and he told The New Stack he expects the combined project to stay open source, likely under Apache 2.0, with the same API as Cloudflare's platform. Cloudflare promises more details over the coming months and gives no ship dates.

Will self-hosting stay first-class? Varda argues that lock-in hurts Cloudflare, and the proof is whether the self-hosted path keeps pace with the hosted one. Watch the merged project's license, its feature parity with Cloudflare's own platform, and whether self-hosted Durable Objects hold up on a fleet you run yourself.

What are the terms? Cloudflare's post says "joining", while The New Stack reports an acquisition and notes the terms were not disclosed. Some commentators speculate Deno was short on funding. Neither company says so, so treat that as speculation.

What to do this week

Date your deadlines, pin your versions, and try the new stack on one small service before you decide anything bigger.

• Write down the two clocks. Use the dates in the table near the top, and ask Deno for confirmed cut-offs, since neither post gave exact days.

• Inventory what runs on Deploy. List every app, its data and its custom domains, and pick the first one to move to Cloudflare Workers.

• Pin and watch the runtime. Lock your Deno version in CI and track the monthly releases, since security patches are what you are being promised.

• Audit Deno-only code. Separate code that uses the Deno namespace from code that relies on web standards or Node.js compatibility, because the second kind tends to move more easily.

• Try self-hosting. Both celld and workerd can be self-hosted today. Run a small Durable Objects app on each, keeping in mind that workerd runs them as a single instance, and note the rough edges.

• Check the satellites. If you use Fresh, Deno Sandbox, Subhosting or enterprise support, ask Deno directly what their status is.

• Subscribe to the follow-ups. Follow both companies' blogs; the merged project's license and roadmap will matter.

What would prove the bet

The bet pays off only if the model travels: if the same code runs on Cloudflare's network and on your own servers.

For Cloudflare, the value is a model: Workers for cheap, globally spread execution, and Durable Objects for state that lives next to the code. Dahl calls the goal compute, storage and communication working together without each application assembling its own infrastructure. His AI-era pitch: Durable Objects combine inexpensive serverless execution, persistent state, WebSockets and a high-level JavaScript interface, which Dahl argues is especially useful for agent harnesses. Picture one small stateful server per agent, user or room.

The New Stack notes that Anthropic bought Bun in December 2025, and Cloudflare acquired VoidZero, the company behind Vite, in June 2026. That is three prominent JavaScript tooling teams under larger companies in about ten months. The terms differ, though. Bun and Vite were promised continued open-source development, while Deno's own development of its runtime is the one that ends, which may say something about where each company thinks the value sits.

Which brings the story back to a 500-line IRC server. Node.js made it simple to write. The team is betting its second act can make it simple to scale, and this time it will be judged on whether the self-hosted version holds up.

Sources

• Ryan Dahl, Deno is joining Cloudflare, Deno blog, October 9, 2026

• Kenton Varda and Ryan Dahl, Deno is joining Cloudflare, Cloudflare blog, October 9, 2026

• Paul Sawers, Cloudflare acquires Node.js creator's startup that copied its serverless playbook, The New Stack, October 9, 2026

• Deno raises $21M to launch a fully managed runtime service, TechCrunch, June 21, 2022

• Cloudflare heads effort to make JavaScript environments interoperable, TechCrunch via Yahoo

• Cloudflare acquires Vite maker VoidZero, IT Brief UK, June 2026

The April 2027 and October 2027 dates are calculated from the announcement date; neither company has published exact cut-off days.