HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
cloudflare
workerd
C++2022–2026
cloudflare / workerd

workerd

The JavaScript / Wasm runtime that powers Cloudflare Workers

30Distinct people
55Mentions
2Explicit recommenders
9.2KGitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

The JavaScript / Wasm runtime that powers Cloudflare Workers

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

You beat us to it! Been meaning to land this but got distracted. https://github.com/cloudflare/workerd/pull/6780 But honestly I love that there are multiple implementations now.

kentonv used a recommendation phrase. 2 indexed comments match. This is a phrase match, not a verdict.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 1:49:46 PM UTC.

No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.

Mentions over time

HN mentions by year55 dated mentions

Observed mentions: 2022-09-27 13:02:06 UTC to 2026-09-23 13:34:38 UTC.

051015202022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 10 mentions; 1 submissions, 9 comments20222023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 11 mentions; 1 submissions, 10 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 6 mentions; 0 submissions, 6 comments20242025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 9 mentions; 0 submissions, 9 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 19 mentions; 0 submissions, 19 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.

View mention counts and date ranges
UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC1019
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC11110
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC606
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC909
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC19019

From the project README

An excerpt from the repository, fetched Nov 13, 2026.

Read the project’s introduction
👷 workerd, Cloudflare's JavaScript/Wasm Runtime workerd (pronounced: "worker-dee") is a JavaScript / Wasm server runtime based on the same code that powers Cloudflare Workers. You might use it: As an application server, to self-host applications designed for Cloudflare Workers. As a development tool, to develop and test such code locally. As a programmable HTTP proxy (forward or reverse), to efficiently intercept, modify, and route network requests. Introduction Design Principles Server-first: Designed for servers, not CLIs nor GUIs. Standard-based: Built-in APIs are based on web platform standards, such as fetch(). Nanoservices: Split your application into components that are decoupled and independently-deployable like microservices, but with performance of a local function call. When one nanoservice calls another, the callee runs in the same thread and process. Homogeneous deployment: Instead of deploying different microservices to different machines in your cluster, deploy all your nanoservices to every machine in the cluster, making load balancing much easier. Capability bindings: workerd configuration uses capabilities instead of global namespaces to connect nanoservices to each other and external resources. The result is code that is more composable -- and immune to SSRF attacks. Always backwards compatible: Updating workerd to a newer version will never break your JavaScript code. workerd's version number is simply a date, corresponding to the maximum "compatibility date" supported by that version. You can always configure your worker to a past date, and workerd will emulate the API as it existed on that date. Read the blog post to learn more about these principles. WARNING: workerd is not a hardened sandbox workerd tries to isolate each Worker so that it can only access the resources it is configured to access. However, workerd on its own does not contain suitable defense-in-depth against the possibility of implementation bugs. When using workerd to run possibly-malicious code, you must run it inside an appropriate secure sandbox, such as a virtual machine. The Cloudflare Workers hosting service in particular uses many additional layers of defense-in-depth. With that said, if you discover a bug that allows malicious code to break out of workerd, please submit it to Cloudflare's bug bounty program for a reward. Getting Started Supported Platforms In theory, workerd should work on any POSIX system that is supported by V8 and Windows. In practice, workerd is tested on: Linux and macOS (x86-64 and arm64 architectures) Windows (x86-64 architecture) On other platforms, you may have to do tinkering to make things work. Building workerd To build workerd, you need: Bazel If you use Bazelisk (recommended), it will automatically download and use the right version of Bazel for building workerd. On Linux, nothing else: the build downloads its own LLVM toolchain (clang, lld and libc++) and a Debian sysroot (see build/deps/llvm.MODULE.bazel), and uses no compiler or libraries from the host. On macOS: Xcode 26.6 installation (available on macOS 26 and higher). Building with just the Xcode Command Line Tools is not being tested, but should work too. On Windows: Install App Installer from the Microsoft Store for the winget package manager and then run install-deps.bat from an administrator prompt to install bazelisk, LLVM, and other dependencies required to build workerd on Windows. Add startup --output_user_root=C:/tmp to the .bazelrc file in your user directory. When developing at the command-line, run bazel-env.bat in your shell first to select tools and Windows SDK versions before running bazel. You may then build workerd at the command-line with: bazel build //src/workerd/server:workerd You can pass --config=release to compile in release mode: bazel build //src/workerd/server:workerd --config=release You can also build from within Visual Studio Code using the instructions in docs/vscode.md. The compiled binary will be located at bazel-bin/src/workerd/server/workerd. If you run a Bazel build before you've installed some dependencies (like Xcode), and then you install the dependencies, you must resync locally cached toolchains, or clean Bazel's cache, otherwise you might get strange errors: bazel fetch --configure --force If that fails, you can try: bazel clean --expunge The cache will now be cleaned and you can try building again. If you have a fairly recent clang packages installed you can build a more performant release version of workerd: bazel build --config=thin-lto //src/workerd/server:workerd Configuring workerd workerd is configured using a config file written in Cap'n Proto text format. For simple projects, workerd serve wrangler.jsonc also accepts a Wrangler config. main is bundled with esbuild, as Wrangler does. The supported fields are name, main, compatibility_date, compatibility_flags, vars, durable_objects, exports, migrations, no_bundle and $schema; any other field is an error. A simple "Hello World!" config file might look like: using Workerd = import "/workerd/workerd.capnp"; const config :Workerd.Config = ( services = [ (name = "main", worker = .mainWorker), ], sockets = [ # Serve HTTP on port 8080. ( name = "http", address = "*:8080", http = (), service = "main" ), ] ); const mainWorker :Workerd.Worker = ( serviceWorkerScript = embed "hello.js", compatibilityDate = "2023-02-28", # Learn more about compatibility dates at: # https://developers.cloudflare.com/workers/platform/compatibility-dates/ ); Where hello.js contains: addEventListener("fetch", event => { event.respondWith(new Response("Hello World")); }); Complete reference documentation is provided by the comments in workerd.capnp. There is also a library of sample config files. Running workerd To serve your config, do: workerd serve my-config.capnp For more details about command-line usage, use workerd --help. Prebuilt binaries are dis
Read the full README on GitHub

What Hacker News says

55 sources
Sorry, this is a bug. It dates back to when Workers only supported 50ms CPU time limits. Back then 100k iterations was enough to exceed the 50ms budget. Now that the limit is 5 minutes this is pretty silly, but since PBKDF2 is considered obsolete and not often used in new code, I guess fixing it never really came up. I would accept a PR to increase the constant to 1M, or higher with a good argument (but most recommendations I see for iteration count are <1M). Constant defined here: https://github.com/cloudflare/workerd/blob/main/src/workerd/...
In PBKDF2 has a 100k-iteration ceiling in Cloudflare Workers
workerd stand-alone is designed to work well at small-medium scale. If we open sourced Cloudflare's production scheduler, nobody would be able to use it because it is explicitly designed for HUGE, globe-spanning scale. Well, nobody except our direct competitors. But the goal with workerd is actually that it should be pretty easy to run, about as easy as Node. Stateless workloads should scale trivially (just add more instances and load balance). For Durable Objects (statefull), currently it doesn't scale well at all, but I'm working on changes[0] so that it scales nicely across a cluster. I intentionally chose a design here that is operationally easy to set up. (Basically: just connect all the nodes to NFSv4.) [0] https://github.com/cloudflare/workerd/pull/6780
In Cloudflare OS: an open platform for agents, apps, and work
It's the same code. The only thing it doesn't include is the global scheduling and orchestration, but you don't actually want that locally. (And honestly... that stuff is a bit of a beast.) Durable Objects are fully supported by workerd (and Cloudflare OS uses them extensively). There is, however, one catch currently: Durable Objects don't scale out well without the global scheduling. For running Cloudflare OS for one user, this is actually no big deal, but a company-wide instance might not work well. But I'm actually fixing that: https://github.com/cloudflare/workerd/pull/6780 Unfortunately didn't get enough time to land it before this release, but it'll come soon. With that I would expect a self-hosted Cloudflare OS on your own cluster to work quite well.
In Cloudflare OS: an open platform for agents, apps, and work
The honest answer is: We implemented the "standard" Cache API back in the early days because it was a standard, one which was intended to be used together with the Service Workers API, which we were also building around back then. But it was never a good fit. The get/put API was designed for a local browser cache, not a distributed cache like Cloudflare's. We probably should have realized this before implementing it, but it really became obvious over the years of actual use. But given we had something that mostly worked for most use cases, it was hard to prioritize redoing it against all the other things on our plate. So we deferred. More recently, architectural changes we've been making in Workers for other reasons happened to make it significantly easier to finally implement this the way we wanted, and we were able to find some engineer
Read the rest
ing time to get it over the line. Gory details for the curious: We've been improving the infrastructure around the notion of workers having multiple "entrypoints", with the ability to parameterize those entrypoints. ctx.props[0] and ctx.exports[1] are part of this. A lot of this was motivated by Dynamic Workers sandboxing, but the concept also presents a clean way to inject a cache between two parts of the same worker, by applying it to the entrypoint and having the worker call itself using ctx.exports. Moreover, the introduction of "channel tokens" made a big difference[2][3]. Essentially I created a way to encode a token (bytes) representing an arbitrary entrypoint to a Worker, complete with its serialized parameters. I did this to enable these entrypoint stubs to be passed over RPC, which is again useful for sandboxing use cases, but it also created a convenient, encapsulated way to pass information through our cache infrastructure about what worker should run at the other end. It's not a huge breakthrough or anything, but I think it made the architecture clearer in everyone's mind to the point that we got excited about using it to implement caching properly, finally. [0] https://developers.cloudflare.com/workers/runtime-apis/conte... [1] https://developers.cloudflare.com/workers/runtime-apis/conte... [2] https://github.com/cloudflare/workerd/blob/main/src/workerd/... [3] https://github.com/cloudflare/workerd/blob/main/src/workerd/...
In Workers Cache
Flatpak manifests include a list of ACLs per app. Flatseal is one way to change the permissions granted to a flatpak. Restarting an app is required for permissions changes to take effect. Audit2allow and desbma/shh can generate policies. systrack, list-syscalls.rb, "B-Side: Binary-Level Static System Call Identification"; https://news.ycombinator.com/item?id=46726677 /? which linux lsm's allow online policy changes: https://www.google.com/search?q=which+linux+lsm%27s+allow+on... Writing to securityfs requires root privs. > for resource metering. Also for optimization with objective costs. > It's closer to metered execution than sandboxing, Linux cgroups support resource quotas. Systemd supports specifying per-unit resource quotas. /? what part of linux containers supports resource quotas? profiling? opcode counting? what part of linux c
Read the rest
ontainers supports resource quotas? profiling? opcode counting? >> Opcode Counting: This is typically done through hardware counters and kernel instrumentation, specifically using perf_events and eBPF (specifically tracepoints or kprobes Kernel docs > admin guide > perf_events: https://docs.kernel.org/admin-guide/perf-security.html : > Usage of Performance Counters for Linux (perf_events) [1] , [2] , [3] can impose a considerable risk of leaking sensitive data accessed by monitored processes. How to mitigate such concerns with lower-level opcode counting for eWASM? Brendan Gegg's > perf examples: https://www.brendangregg.com/perf.html , and BPF/Perf book: https://www.brendangregg.com/bpf-performance-tools-book.html I respectfully doubt that it's safe to trust runtime sandboxing. Containersec folks can probably explain why userspace filtering can never solve as well bubblewrap README > Sandboxing: https://github.com/containers/bubblewrap#sandboxing arch wiki > Bubblewrap > Using portals; XDG Desktop Portal: https://wiki.archlinux.org/title/Bubblewrap#Using_portals > cloudflared/workerd: https://github.com/cloudflare/workerd : >> WARNING: workerd is not a hardened sandbox wasmtime-mte requires support for ARM64 Memory Tagging Extensions.
In Show HN: CSL-Core – Formally Verified Neuro-Symbolic Safety Engine for AI
From "Show HN: NPM install a WASM based Linux VM for your agents" re: https://github.com/deepclause/agentvm .. https://news.ycombinator.com/item?id=46686346 : >> How to run vscode-container-wasm-gcc-example with c2w, with joelseverin/linux-wasm? > linux-wasm is apparently faster than c2w. container2wasm issue #550: https://github.com/container2wasm/container2wasm/issues/550#... vscode-container-wasm-gcc-example : https://github.com/ktock/vscode-container-wasm-gcc-example Cloudflare Runners also run WASM; with workerd: cloudflare/workerd : https://github.com/cloudflare/workerd ... "Cage" implements ARM64 MTE Memory Tagging Extensions support for WASM with LLVM emscripten iirc: - "Cage: Hardware-Accelerated Safe WebAssembly" (2024) https://news.ycombinator.com/item?id=46151170 : > [ llvm-memsafe-wasm , wasmtime-mte , ]
In Show HN: Amla Sandbox – WASM bash shell sandbox for AI agents
The challenge with V8 is finding a wrapper for it that doesn't come with a big warning NOT to use it as a sandbox for untrusted code - here's the workerd one https://github.com/cloudflare/workerd?tab=readme-ov-file#war... and here's the PyMiniRacer section: https://bpcreech.com/PyMiniRacer/architecture/#security-goal... I looked at GraalVM but was put off by the licensing situation: https://www.graalvm.org/22.3/reference-manual/embed-language... > GraalVM Enterprise provides the experimental Sandbox Resource Limits feature that allows for the limiting of resources used by guest applications. These resource limits are not available in the Community Edition of GraalVM. Part of my requirements for a sandbox are strong guarantees against memory or CPU exhaustion from poorly written or malicious code.
In JavaScript engines zoo – Compare every JavaScript engine

Showing the 15 most recent of 55 sources. Enable JavaScript to search and browse every indexed mention.

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.