Edge Computing with Cloudflare Workers

391 posts · Feb 2013 – Oct 2026

What this trail covers

Cloudflare Workers has evolved to support self-hosting via the integration of Deno's celld and Cloudflare's workerd. This unification aims to make it radically easy to build and operate distributed applications on developers' own infrastructure, leveraging primitives like Durable Objects, Queues, KV, and Durable Execution. The combined effort focuses on simplifying the management of distributed systems, including compute, relational databases, queues, and real-time communication, with object storage as the primary external dependency for celld.

All Cloudflare trails

Oct 2026Deno is joining CloudflareThis post announces the joining of the Deno team with Cloudflare, specifically merging Deno's celld project with Cloudflare's workerd. The core contribution is the integration of celld's distributed systems capabilities with workerd's Workers and Durable Objects runtime. This aims to provide a self-hostable, distributed version of the Workers programming model, addressing the difficulty of running distributed applications outside of Cloudflare's managed network. Celld's focus on a single binary with object storage as its only external dependency is highlighted as a simplification for developers managing distributed applications.
Oct 2026Streamline: custom video pipelines with Cloudflare Stream and WorkersThis post introduces Streamline, a new developer playground for building custom video pipelines on Cloudflare's Developer Platform. It details the architecture involving Cloudflare Containers for the Media Engine (using FFmpeg for processing) and Workers/Durable Objects for the controlling Application. Key technical contributions include: overriding `onActivityExpired()` in Containers to maintain long-running media processing, a session-based API (`@cloudflare/streamline/client`) for controlling pipelines, support for RTMP and HLS inputs, and the ability to update annotations dynamically. It also outlines the configuration structure for defining input, operations (e.g., overlay, encode, subtitle), and output.
Sep 2026Cloudflare Containers, rebuilt to scale agent sandboxesThis post details the rearchitecture of Cloudflare Containers to support agent sandboxes. Key technical contributions include the introduction of a `durable_object` scheduling policy that allows runtime selection of sandbox images and instance types, a redesigned runtime that reduces median startup time from 4.049s to 648ms, and the public beta of filesystem snapshots. The changes shift control over sandbox configuration from deploy-time to runtime code within the Durable Object, enabling more flexible rollouts and faster initialization.
Sep 2026Next.js applications, powered by Vite: introducing Vinext 1.0This post announces Vinext 1.0, a framework that enables Next.js applications (both Pages Router and App Router) to be deployed on Cloudflare Workers and other platforms. Key contributions include: achieving over 99% test compatibility with Next.js features, building out a comprehensive test suite that runs the Next.js end-to-end test suite nightly, and implementing features like App Router and Pages Router support, complete page lifecycle management (server rendering, pre-rendering, ISR), shared caching functions with support for Workers Cache, Next.js-compatible tracing for OpenTelemetry and Sentry, and first-class runtime support for Workers. A significant new capability introduced is 'cache warming,' which moves page prerendering from the build machine to Cloudflare's network, pre-populating caches before deployment to production. This is achieved by deploying a new Worker version to 0% traffic, requesting pages from it, and then promoting the deployment once caches are populated.
Sep 2026Supporting native Rust in Workers with the new Emscripten target for wasm-bindgenThis post details the integration of the Emscripten `wasm32-unknown-emscripten` target with wasm-bindgen, enabling native Rust and Tokio applications to run on Cloudflare Workers. It describes the cooperative engineering effort between Google and Cloudflare to achieve seamless interoperability between Emscripten and wasm-bindgen toolchains. Significant contributions include patches for Rust libraries to support the Emscripten target and substantial work on Tokio to enable its async runtime within the Workers' single-threaded JavaScript event loop. This was achieved through two primary approaches: supporting reentrant JSPI with careful thread-local context management, and designing a `LocalEventLoop` for Tokio that integrates with host event loops by splitting the runtime's polling and waiting phases.
Advertisement
Sep 2026The road to the agentic browser: A Kitesurf updateThis post details the integration of WebMCP support into Kitesurf, enabling agents to interact with websites programmatically via exposed functions. It also announces expanded API coverage for Kitesurf, including CSS Layout, CSSOM, CSS Typed OM, and Custom Elements, along with improved iframe behavior and URL-based module resolution. Significant progress in Web Platform Test coverage (730,000+ subtests) is highlighted. Internal optimizations for agent efficiency are described, focusing on reducing Wasm-JavaScript boundary crossings and improving timer/script loading. Kitesurf now has full Browser Run API coverage and supports Quick Actions from Worker scripts. A major new capability is the ability to run Kitesurf in the terminal using Kitty graphics protocol or ANSI text mode, decoupling rendering logic from the core Kitesurf execution.
Sep 2026Python Workers are now generally availableThis post announces the General Availability (GA) of Python Workers, a significant evolution of the Cloudflare Workers platform. Key contributions include: 1. Native support for Cloudflare bindings, eliminating the need for explicit JavaScript glue code for RPC boundaries. 2. Implementation of WSGI/ASGI connectors (`workers.asgi`, `workers.wsgi`) to seamlessly run Python web frameworks (FastAPI, Django, Flask) on the Workers platform. 3. A socket system call implementation using the Workers `connect` API, enabling Python database drivers to connect to services like Hyperdrive (PostgreSQL/MySQL). 4. Standardization of a platform for running Python in browser runtimes via PEP 783 and PyEmscripten, benefiting the broader Python-on-WebAssembly community. 5. Stabilization of the Pyodide build toolchain and integration with `cibuildwheel` for easier package creation.
Sep 2026How we rebuilt Cloudflare Workers’ module registry for Node.js compatibilityIntroduced a new module registry implementation in `workerd` that resolves module specifiers as URLs, supports `import.meta.url` and `import.meta.resolve()`, handles query strings and fragments for module identity, correctly validates import attributes, and enables lazy compilation of modules. This significantly improves Node.js compatibility for Workers.
Aug 2026A revisit of remote Spectre attacks on Cloudflare WorkersThis post details a reassessment of remote Spectre attacks against Cloudflare Workers, identifying a limitation in the existing Dynamic Process Isolation (DyPrIs) defense. The research successfully demonstrated a remote Spectre attack in the production environment, leaking data at 12 bit/s with 99% accuracy. As a consequence, Cloudflare improved DyPrIs, integrated the V8 Sandbox, and added an in-process isolation mechanism to further mitigate memory disclosure attacks. The research also highlights the challenges of mounting such attacks in a production environment, including the need for a reliable remote timer and signal amplification techniques.
Aug 2026Give any website a WebMCP interfaceIntroduced WebMCP support to Cloudflare Workers, enabling websites to expose tools for AI agents via an edge-injected bridge script. This involves adding a `<script>` tag to HTML responses and serving a bridge script from the edge. The bridge registers tool packs (e.g., Content Credentials, Site MCP Server) with the browser's `document.modelContext`. The Content Credentials pack scans images for C2PA metadata, and the Site MCP Server pack allows agents to interact with the origin's MCP server. This extends edge computing to facilitate agent-browser interaction.
Aug 2026Introducing Kitesurf: The agent-first browser that runs in V8 isolates on Cloudflare WorkersThis post introduces Kitesurf, a new agent-first browser built on Cloudflare Workers. It details the technical decisions and architecture behind Kitesurf, including the use of Rust compiled to WebAssembly, dynamic workers, isolation, statelessness, and a Chrome DevTools Protocol (CDP) interface for compatibility with tools like Puppeteer. The post highlights the trade-offs made for agentic use (e.g., prioritizing token count over visual perfection) and the challenges of building a browser engine for AI. It also discusses the use of Web Platform Tests (WPT) and integration/visual regression testing for quality assurance, and the role of AI agents in accelerating development.
Aug 2026The next generation of MCPThe Model Context Protocol (MCP) has been updated to a stateless protocol, removing the need for stateful connections and simplifying server deployment to Cloudflare Workers. This change eliminates the requirement for Durable Objects for MCP servers, allowing them to run on request-scoped infrastructure. Elicitation has been re-architected using Multi Round-Trip Requests (MRTR) to replace open streams. MCP requests now include `Mcp-Method` and `Mcp-Name` headers for easier integration with gateways, rate limiters, and WAFs. Authorization mechanisms have been tightened, preferring pre-registered clients and Client ID Metadata Documents (CIMD) over Dynamic Client Registration (DCR). A formal feature lifecycle (Active, Deprecated, Removed) has been introduced for MCP features.
Aug 2026Cloudflare OS: an open platform for agents, apps, and workThis post introduces Cloudflare OS, an open platform for agents, apps, and work. It details the agent workspace, which allows agents to write and run code in an isolated runtime, grounded in company context and skills. It also introduces a new security and governance framework, including Gatekeepers that mediate access to external services and enforce policies based on agent observations. The platform supports building personal, modifiable apps and running deterministic workflows. It integrates with existing MCP servers via MCP Server Portals.
Aug 2026Run CI/CD for millions of repos — on your platform, on CloudflareIntroduces the ability to run CI/CD pipelines on Cloudflare using Cloudflare Workflows and a new CI SDK. This enables automated builds, linting, testing, dependency caching, and conditional deployment directly on the platform. It leverages Artifacts for code storage and the Sandbox SDK for isolated execution. The post also details the integration with Wrangler for deployment and introduces self-healing CI capabilities using AI agents.
Aug 2026The Agent Development Lifecycle has arrived on CloudflareIntroduces the Agent Development Lifecycle (ADLC) as a successor to the SDLC for agent-driven software development. Details new tools and capabilities enabling agents to manage more of the SDLC: @cloudflare/ci for CI/CD, local OpenTelemetry traces for observability in development, Cloudflare Agents and Agent Traces for observing agent behavior, and a system for enforcing engineering standards using AI. Discusses the requirements for 'software factories' and how Cloudflare Workflows and Artifacts provide the necessary programmatic, scalable, reproducible, real-time, atomic, permissioned, and self-improving platform capabilities to support agents driving the entire development lifecycle.
Aug 2026Your agent can now debug Workers with local tracingIntroduces automatic OpenTelemetry tracing for local Cloudflare Workers development when using `wrangler dev` or `vite dev` in an agent session. Agents can now automatically discover and query these traces and correlated logs via the Local Explorer API to debug issues, inspect local binding state (KV, R2, D1, Durable Objects, Workflows), and verify fixes without deploying code. This leverages the existing workerd instrumentation and Miniflare's local trace store.
Aug 2026Your agent needs a computer, not a container — introducing @cloudflare/computerIntroduces @cloudflare/computer, an open-source library for building agentic systems. It provides a unified runtime that abstracts compute primitives (isolates, containers, browsers) and offers a durable filesystem backed by SQLite. Agents can leverage this workspace to execute tasks using either isolate-based execution (via dynamic workers and just-bash) or container-based execution (via Cloudflare Containers with FUSE mounts). The library includes tools for file manipulation, shell commands, and integration with AI models and services, aiming to improve the scalability and efficiency of agent development.
Aug 2026Cloudflare Workers and Containers now support inbound TCP connections and gRPCIntroduces the `connect(socket)` handler for inbound TCP connections in Cloudflare Workers, enabling routing of raw TCP sockets from Spectrum. Extends Workers to support full-duplex communication with gRPC servers running in containers or other Workers. Adds automatic conversion between gRPC and gRPC-web, allowing Workers to serve and consume gRPC APIs without requiring clients to change their implementation. This enables the deployment of gRPC-based applications, including real-time voice AI, on Cloudflare's edge network.
Aug 2026Workers RPC now works across Python and JavaScriptThis post introduces cross-language RPC support for Cloudflare Workers, enabling seamless communication between JavaScript and Python Workers. It details the use of Pyodide's FFI and a custom `workers-runtime-sdk` Python package for automatic type conversion and handling of Workers-specific objects like Request and Response. The post provides examples of calling methods across languages, sharing objects, and using Python packages from JavaScript Workers. It also highlights the open-source nature of the implementation within `workerd` and `workers-runtime-sdk`.
Jul 2026An API for MoQ: provision your own isolated relaysIntroduced a MoQ provisioning API that allows users to create isolated relays across Cloudflare's global network. This API supports draft-14 and draft-16 of the MoQ Transport protocol and enables the issuance of separate credentials for publishers and subscribers, providing access control and isolation for applications. The API manages relays and tokens, which are scoped to specific operations (publish, subscribe) and can have expiration and revocation. The post also details the integration of these features with the Cloudflare dashboard and provides examples using the moq-rs tools.
Jun 2026How we found a bug in the hyper HTTP libraryThis post details the debugging of a race condition in the hyper HTTP library that caused intermittent truncation of large image transformations when using the Cloudflare Images binding. The issue was traced to a timing-dependent interaction between hyper's buffer management and the kernel's socket buffers, particularly after a rearchitecture that replaced an intermediary service with a direct Unix socket connection. The fix involved a four-line code change in hyper to correctly handle buffer flushing and socket shutdown under specific concurrency conditions.
Jun 2026Temporary Cloudflare Accounts for AI agentsIntroduces Temporary Cloudflare Accounts for Agents, enabling `wrangler deploy --temporary` for frictionless, 60-minute deployments of Workers. This feature allows AI agents to deploy and iterate on code without requiring manual account signup or authentication, with an option to claim the temporary account for permanent use.
Jun 2026Bringing more agent harnesses and frameworks to Cloudflare, starting with FlueThis post introduces Flue, a new open-source framework built on the Cloudflare Agents SDK, designed for building production-grade AI agents. It details how Flue leverages Cloudflare's primitives: durable execution via `runFiber()`, `stash()`, and `onFiberRecovered()` for resilient agent turns; secure code execution using `@cloudflare/codemode` and Dynamic Workers; and a durable virtual filesystem with `@cloudflare/shell` for workspace tasks. The post positions this as a three-layer stack (framework, harness, runtime) for AI development.
Jun 2026VoidZero is joining CloudflareThis post announces the acquisition of VoidZero, the company behind Vite, Vitest, Rolldown, Oxc, and Vite+, by Cloudflare. It details how Cloudflare plans to integrate Vite into its developer platform, enabling developers to run Vite applications on Cloudflare Workers using the `workerd` runtime. The post highlights the development of a Cloudflare Vite plugin that allows `vite dev` to run server code within `workerd` locally, mirroring production environments. It also discusses how AI is changing software development and how Vite's fast feedback loops are beneficial for AI-generated applications. Cloudflare aims to move its own CLI tooling onto Vite, creating a unified experience for developers. The post emphasizes that Vite will remain open-source, vendor-agnostic, and community-driven, with Cloudflare committing resources and a $1 million ecosystem fund.
May 2026Announcing Claude Managed Agents on CloudflareThis post details the integration of Claude Managed Agents with Cloudflare Sandboxes, extending the edge computing platform's capabilities to host and execute AI agents. It introduces the concept of 'decoupling the brain from the hands,' where the agent loop runs on Anthropic's platform while Cloudflare provides the execution environment. Key contributions include the use of lightweight V8 isolates (Dynamic Workers) and traditional microVMs (Cloudflare Containers) for agent execution, enhanced security through outbound proxies for zero-trust authentication and private service connectivity (Cloudflare Mesh, Workers VPC), and the integration of agent-specific tools like Browser Run and email capabilities. The post also highlights the default deployment template and its features for sandbox control, observability, and custom tool execution.
May 2026Browser Run: now running on Cloudflare Containers, it’s faster and more scalableBrowser Run migrated from shared Browser Isolation infrastructure to Cloudflare Containers, leveraging Durable Objects for regional pools of pre-warmed browser containers to reduce latency. The state management of containers was migrated from Workers KV to D1 with batched writes via Cloudflare Queues to overcome KV's eventual consistency and throughput limitations, enabling higher scale and faster capacity adjustments. This migration also allows for faster browser image upgrades, enabling features like WebGL and WebMCP.
May 2026Introducing Dynamic Workflows: durable execution that follows the tenantIntroduced Dynamic Workflows, a library that enables a single Worker (Worker Loader) to route `create()` calls to different tenant-specific code and dispatch `run(event, step)` back to that same code when the workflow executes. This is built on top of Dynamic Workers and Durable Object Facets, extending the dynamic primitive to durable execution. The library handles the envelope-and-unwrap glue between static bindings and dynamic tenant code, allowing for per-tenant workflows with full durable execution capabilities.
Apr 2026Making Rust Workers reliable: panic and abort recovery in wasm‑bindgenThis post details the implementation of `panic=unwind` support for Rust on WebAssembly via the WebAssembly Exception Handling proposal, enabling stateful recovery from panics without instance reinitialization. It also describes enhancements to abort recovery mechanisms, including new abort handlers and reentrancy guards, to prevent invalid states from persisting. The contribution includes modifications to the wasm-bindgen toolchain to support these features, such as adding support for try/catch instructions in the Walrus parser and marking exports as `extern "C-unwind"`. Additionally, an experimental `--reset-state-function` feature for wasm-bindgen is introduced to facilitate abort recovery for Wasm libraries used in JavaScript applications.
Apr 2026Building the agentic cloud: everything we launched during Agents Week 2026This post details numerous new primitives for the agentic cloud built on Cloudflare Workers. Key announcements include: Sandboxes for persistent, isolated agent environments; Durable Object Facets for agent-generated SQLite databases; a rearchitected Workflows control plane supporting 50,000 concurrency; Cloudflare Mesh for secure, private network access for agents; Managed OAuth for Access to make internal apps agent-ready; enhanced API tokens and resource-scoped permissions for non-human identities; Project Think for the next generation of AI agents; an experimental voice pipeline for real-time voice interactions; Cloudflare Email Service beta for agents; a unified inference layer for agents supporting 14+ providers and multimodal models; a custom technology stack for running large language models; Unweight for lossless LLM compression; Agent Memory for persistent agent memory; AI Search for agent-specific search; Browser Run for agent browsers with higher concurrency; a unified CLI (cf) and Agent Lee for in-dashboard agent interaction; Flagship for native feature flags; PlanetScale database integration; and the Cloudflare Registrar API beta. Additionally, it introduces the Agent Readiness score and Redirects for AI Training to prepare the web for agents, and a network performance update with FL2 architecture.
Apr 2026Agents that remember: introducing Agent MemoryIntroduced Agent Memory, a managed service for AI agents that provides persistent memory by extracting information from conversations and making it available for retrieval. This addresses the challenge of context rot in large language models by preserving important information without filling up the context window. Agent Memory offers operations for ingesting conversations, remembering specific details, recalling information, listing memories, and forgetting memories. It integrates with Cloudflare Workers via a binding and also offers a REST API. The service includes a multi-stage ingestion pipeline with deterministic ID generation, extraction, verification, classification, and storage of memories.
Apr 2026Introducing Flagship: feature flags built for the age of AIThis post introduces Flagship, Cloudflare's native feature flag service, designed for the age of AI-driven code generation and autonomous agentic workflows. Flagship leverages Cloudflare's edge infrastructure (Workers, Durable Objects, KV) for low-latency, local evaluation, eliminating the need for external API calls during request processing. It integrates with the OpenFeature standard for provider portability and offers a direct binding for Cloudflare Workers, allowing for seamless integration and high-performance feature flag evaluation within the runtime. The service supports complex targeting rules, nested logical conditions, and percentage-based rollouts, enabling safe and controlled release of AI-generated code and autonomous agent deployments.
Apr 2026Project Think: building the next generation of AI agents on CloudflareIntroduces Project Think, a new generation of the Agents SDK with primitives for building long-running AI agents. Key additions include durable execution with fibers (crash recovery, checkpointing, automatic keepalive), sub-agents via Facets (isolated child Durable Objects with their own SQLite and typed RPC), persistent sessions (tree-structured messages, forking, compaction, full-text search via FTS5), and sandboxed code execution using Dynamic Workers with a capability model. Also introduces the 'execution ladder' and self-authored extensions. The post highlights the shift from ephemeral agents to infrastructure-like agents, enabled by Durable Objects, changing the scaling math and economics of agent deployment.
Apr 2026Add voice to your agentIntroduces an experimental voice pipeline for the Agents SDK, enabling real-time voice interaction with agents. This includes `withVoice` and `withVoiceInput` wrappers, React hooks (`useVoiceAgent`, `useVoiceInput`), and a `VoiceClient`. It integrates with Workers AI for STT (Deepgram Flux/Nova 3) and TTS (Deepgram Aura), and maintains conversation history via Durable Objects and SQLite. The pipeline supports streaming responses for lower latency and allows voice and text to share the same agent state and connection.
Apr 2026Browser Run: give your agents a browserRenamed Browser Rendering to Browser Run and introduced several new features to support AI agents interacting with the web. Key additions include Live View for real-time observation, Human in the Loop for agent intervention, a direct Chrome DevTools Protocol (CDP) endpoint for enhanced control and compatibility with existing tools, MCP Client Support for AI coding assistants, WebMCP support for agent-friendly website navigation, Session Recordings for debugging, and increased concurrency limits (120 browsers). The /crawl endpoint was also enhanced for well-behaved web crawling.
Apr 2026Rearchitecting the Workflows control plane for the agentic eraThe Workflows control plane was rearchitected from V1 to V2 to support increased scale driven by agentic workloads. V1 used a single account-level Durable Object (DO) as a bottleneck. V2 introduces SousChef (manages subsets of instances per workflow) and Gatekeeper (distributes concurrency slots) to horizontally scale the system. The source of truth for instance existence is now its Engine DO, and instance lifecycle mechanisms are horizontally scalable and distributed. The new Account singleton stores minimal metadata and has an invariant maximum concurrent requests. The migration process involved seamlessly transitioning customers and instances to the new V2 architecture without downtime.
Apr 2026Durable Objects in Dynamic Workers: Give each AI-generated app its own databaseIntroduced Durable Object Facets, a beta feature allowing Dynamic Workers to load and instantiate Durable Object classes dynamically. This enables AI-generated applications to have persistent state by composing Durable Objects with Dynamic Workers, where each facet gets its own isolated SQLite database. Provided a complete example of an AppRunner Durable Object that loads and runs agent-generated Durable Object code as a facet.
Apr 2026Agents have their own computers with Sandboxes GAThis post announces the General Availability of Cloudflare Sandboxes and Cloudflare Containers. It details recent enhancements to Sandboxes, including secure credential injection via a programmable egress proxy, PTY support for live terminal sessions, persistent code execution contexts (Python, JS, TS) that retain state, background process management with live preview URLs, filesystem watching via inotify, snapshotting for session recovery, and higher limits with active CPU pricing. It also provides code examples for using these features.
Apr 2026Dynamic, identity-aware, and secure Sandbox authIntroduced outbound Workers for Sandboxes and Containers, acting as programmatic egress proxies. These proxies allow for dynamic request interception, modification, and control, enabling features like secure credential injection (e.g., API tokens via `env.SECRET` or KV lookups), integration with Cloudflare Developer Platform services (R2, KV, Agents) via bindings, and dynamic network policy enforcement using `outboundHandlers` and `setOutboundHandler`. This enhances zero-trust security, observability, and flexibility for agentic workloads.
Apr 2026Welcome to Agents WeekThis post introduces the concept of 'Agents Week' and argues that the current cloud infrastructure, built for a one-to-many application model, is ill-suited for the one-to-one, ephemeral nature of AI agents. It highlights Cloudflare Workers' V8 isolates as the ideal primitive for agent execution due to their speed, efficiency, and scalability, contrasting them with containers. The post announces the open beta of Dynamic Workers, which further enables per-request execution environments. It also discusses the 'horseless carriage' phase of agent development, where existing infrastructure is being adapted, and emphasizes the need for integrated security and economic models for agents.
Apr 2026Introducing EmDash — the spiritual successor to WordPress that solves plugin securityThis post introduces EmDash, a new serverless CMS built on Cloudflare Workers and Astro, designed as a spiritual successor to WordPress. The core engineering contribution is the secure plugin architecture, which leverages Cloudflare Workers' Dynamic Workers and capability bindings to sandbox plugins. This approach provides explicit, static declarations of plugin permissions (e.g., 'read:content', 'email:send') and prevents direct access to sensitive resources like databases or filesystems, addressing the fundamental security issues of the WordPress plugin model. The post also highlights the integration of x402 for on-demand content payment and the use of Astro for the underlying web framework.
Mar 2026How we use Abstract Syntax Trees (ASTs) to turn Workflows code into visual diagramsThis post details the technical implementation of generating visual diagrams for Cloudflare Workflows code. It describes the challenges of visualizing dynamically executed code, the process of fetching and parsing minified JavaScript using the `oxc-parser` via a Rust Worker compiled to WebAssembly, and the generation of an intermediate graph representation from the AST. It highlights the use of `Promise` and `await` relationships to track parallel and blocking execution, and the mapping of AST nodes to pre-defined workflow node types for rendering.
Mar 2026Sandboxing AI agents, 100x fasterThis post introduces the Dynamic Worker Loader API, a new feature for Cloudflare Workers that allows a Worker to dynamically instantiate and sandbox new Workers at runtime. This provides a lightweight and performant sandbox for AI agents, leveraging the existing isolate-based execution model of Cloudflare Workers. The API supports specifying code, environment variables, and network access policies, and integrates with TypeScript for defining agent APIs. It offers significant advantages over container-based sandboxing in terms of speed, memory efficiency, scalability, and latency.
Feb 2026We deserve a better streams API for JavaScriptThis post critiques the existing Web Streams API, highlighting issues with excessive ceremony, the locking problem, and the complexity of BYOB reads. It proposes an alternative approach built around JavaScript language primitives that offers significant performance improvements (2x-120x) over the current standard. The author's experience implementing and debugging Web Streams in Cloudflare Workers and Node.js informs this critique and the proposed solution.
Feb 2026How we rebuilt Next.js with AI in one weekThis post introduces vinext, a new project that reimplements the Next.js API surface on Vite, enabling it to deploy to Cloudflare Workers. It details the motivation for building vinext as an alternative to adapting Next.js output (via OpenNext or adapters), highlighting the fragility and limitations of the latter. The post presents benchmarks showing vinext's faster build times and smaller client bundles compared to Next.js. It also describes the deployment process to Cloudflare Workers, including the use of KV for Incremental Static Regeneration (ISR) and the ability to leverage Cloudflare-specific services like Durable Objects and AI bindings. The project is positioned as experimental but has extensive test coverage and early customer adoption.
Jan 2026Building vertical microfrontends on Cloudflare’s platformThis post introduces a new Worker template for Vertical Microfrontends (VMFE) that allows mapping multiple independent Cloudflare Workers to a single domain. It details how this pattern enables teams to own entire slices of an application's functionality (UI to CI/CD) defined by URL paths. The post explains how to achieve visual unification using CSS View Transitions and improve perceived performance with the Speculation Rules API for prefetching. It also describes the use of service bindings in a 'Router' Worker to route requests to individual microfrontend Workers, demonstrating a practical application of Cloudflare's edge computing capabilities for complex application architectures.
Jan 2026Introducing Moltworker: a self-hosted personal AI agent, minus the minisThis post introduces Moltworker, a middleware Worker and adapted scripts that enables running the self-hosted AI agent Moltbot on Cloudflare's Developer Platform. It details how Moltbot's AI provider integrations are managed via Cloudflare AI Gateway, how the Sandbox SDK is used to run Moltbot's gateway runtime in isolated environments, how R2 is used for persistent storage of session memory and conversations, and how Browser Rendering is utilized for web automation tasks. The post also highlights the increasing Node.js compatibility of Cloudflare Workers, enabling more complex applications to run on the platform.
Jan 2026Building a serverless, post-quantum Matrix homeserverThis post details the porting of the Synapse Matrix homeserver to Cloudflare Workers, demonstrating a serverless architecture for a traditionally stateful and operationally heavy application. It maps Synapse's storage requirements (PostgreSQL, Redis, filesystem) to Cloudflare primitives: D1 for event data, KV for ephemeral state like OAuth codes, R2 for media storage, and Durable Objects for atomic operations like E2EE key management and real-time room events. The post also highlights the automatic application of post-quantum TLS (X25519MLKEM768) for all connections to the Worker, and the implementation of a full OAuth 2.0/OIDC provider.
Dec 2025How Workers powers our internal maintenance scheduling pipelineThis post details the development of a maintenance scheduling pipeline using Cloudflare Workers. Key technical contributions include: 1. Designing a graph processing interface inspired by Facebook's TAO to model objects (e.g., routers) and associations (e.g., Aegis pools) for maintenance constraints. 2. Implementing a fetch pipeline middleware layer for Workers to handle subrequest limits, including request deduplication (inspired by Go's singleflight), LRU caching, CDN caching, and backoff retries. 3. Demonstrating a 100x reduction in response sizes and achieving ~99% cache hit rate through targeted data fetching and the fetch pipeline.
Dec 2025Python Workers redux: fast cold starts, packages, and a uv-first workflowThis post details the technical advancements in Cloudflare Workers for Python support. Key contributions include: 1. Integration of Pyodide for running Python in WebAssembly, enabling support for pure Python packages and many dynamic library packages. 2. Development of `pywrangler` tooling around `uv` for simplified package management and deployment. 3. Implementation of memory snapshots for significantly reducing Python Worker cold start times (over 2.4x faster than AWS Lambda without SnapStart), achieved by capturing and restoring the Pyodide runtime's linear memory. 4. Strategies for handling entropy at startup to ensure proper randomness after memory snapshot restoration. 5. Generation of type hints for Worker bindings using `pywrangler types` for improved developer experience with tools like Pylance and mypy.
Nov 2025Connecting to production: the architecture of remote bindingsThis post details the architecture of Cloudflare's new remote bindings feature for Workers. It explains how the local development environment (workerd) now translates binding calls to remote resources (like KV, R2, D1, AI) by proxying requests to production runtime instances. This is achieved by leveraging the existing service binding architecture, where platform Workers communicate with authored Workers via HTTP or JSRPC. For JSRPC-backed bindings, websockets and Cap'n Web are used for communication. The post also outlines how this functionality is integrated into tools like Vite and Vitest.
Nov 2025A closer look at Python Workflows, now in betaIntroduces Python support for Cloudflare Workflows, enabling developers to orchestrate multi-step applications using Python. This leverages Pyodide for CPython execution within the Workers runtime and provides Pythonic SDKs for defining workflows, including support for decorators to handle Python's lack of anonymous callbacks and enabling DAG execution through `asyncio.gather` and declarative approaches.
Nov 2025Async QUIC and HTTP:3 made easy- tokio-quiche is now open-sourceThis post announces the open-sourcing of tokio-quiche, an asynchronous QUIC library that combines quiche and the Tokio async runtime. It details how tokio-quiche lowers the barrier to entry for integrating QUIC and HTTP/3 by providing IO integration code, and how it uses actors to drive the QUIC and HTTP/3 state machine. It also introduces the `ApplicationOverQuic` trait and the `H3Driver` for building QUIC applications, and explains the internal architecture with `InboundPacketRouter` and `IoWorker` actors.
Nov 2025Building a better testing experience for Workflows, our durable execution engine for multi-step applicationsIntroduced new APIs (`introspectWorkflowInstance`, `introspectWorkflow`) within the `cloudflare:test` module for granular, isolated, and local testing of Cloudflare Workflows. These APIs leverage `vitest-pool-workers` and a combination of privileged local-only APIs and Remote Procedure Calls (RPC) to allow developers to mock step results, events, and control workflow execution, significantly improving the debugging and testing experience for complex orchestrations.
Oct 2025Unpacking Cloudflare Workers CPU Performance BenchmarksThis post details the investigation and resolution of performance disparities in Cloudflare Workers benchmarks compared to Vercel. Key contributions include: 1. Updating the scheduling algorithm to better handle CPU-bound workloads by spinning up new isolates faster, ensuring that billing accurately reflects CPU time and not scheduling delays. 2. Tuning the V8 garbage collector by allowing more dynamic young generation sizing, leading to an approximate 25% performance boost for benchmarks and other Workers. 3. Optimizing the OpenNext adapter for Next.js by reducing unnecessary data buffer copies and improving stream handling, addressing a significant portion of the remaining performance gap.
Sep 2025Code Mode: the better way to use MCPIntroduces 'Code Mode' for Cloudflare Agents SDK, enabling LLMs to generate and execute TypeScript code to interact with MCP servers. This approach improves agent capabilities by leveraging LLMs' proficiency in code generation over direct tool calls, leading to better handling of complex tools and multi-tool sequences. The post details the conversion of MCP schemas to TypeScript APIs and the use of a secure sandbox for code execution.
Sep 2025Eliminating Cold Starts 2: shard and conquerThis post introduces and details the "Worker sharding" technique, which uses a consistent hash ring to route requests to existing Worker instances within a data center. It explains the problem of increased cold start times due to relaxed limits on script size and startup CPU, and how coalescing requests onto a single instance improves warm request rates and memory efficiency. The post elaborates on the implementation using a consistent hash ring, analogous to HTTP cache sharding, to manage Worker placement across servers and minimize cold starts when servers are added or removed.
Sep 2025Cloudflare's developer platform keeps getting better, faster, and more powerful. Here's everything that's new.This post details significant enhancements to the Cloudflare Workers platform, expanding its compatibility with Node.js APIs (node:fs, node:https, node:dns, node:net, node:tls, node:crypto, process.env), increasing container instance limits and concurrency, and providing more disk (20GB) and CPU (4 vCPU) for Workers Builds (now GA). Remote Bindings for local development are now GA, allowing connection to deployed resources like R2 buckets. AI Search (formerly AutoRAG) now supports BYO Provider Keys via AI Gateway, enabling the use of models from OpenAI and Anthropic. New integrations include Planetscale Postgres, Cloudflare Email Service, Cloudflare Data Platform for distributed SQL, and VibeSDK. Browser Rendering API with Playwright is GA, supporting 30 concurrent browsers. R2 Infrequent Access and Media Transformations are also GA.
Sep 2025Safe in the sandbox: security hardening for Cloudflare WorkersThis post details security hardening of the Workers Runtime using hardware-assisted memory protection keys to isolate isolates and the V8 sandbox to mitigate memory corruption attacks, further enhancing the security boundary for third-party code execution.
Sep 2025A year of improving Node.js compatibility in Cloudflare WorkersThis post details the significant expansion of Node.js compatibility within Cloudflare Workers over the past year. Key technical contributions include: native implementation of a substantial subset of Node.js standard library APIs (console, crypto, dns, fs, http, https, net, process, timers, tls, zlib) in TypeScript and C++, improved HTTP client support built on the Fetch API, HTTP server support built on existing request handling, DNS queries routed through 1.1.1.1, and the implementation of a virtual, per-Worker file system for temporary storage using `node:fs` APIs. The post highlights the shift from polyfills to native runtime implementations for better performance and closer Node.js behavior.
Sep 2025Deploy your own AI vibe coding platform — in one click!This post introduces VibeSDK, an open-source AI vibe coding platform that leverages Cloudflare Workers for scalable deployment and isolated development environments. It integrates LLM models via Agents SDK, provides secure sandboxes for untrusted AI-generated code, and offers features like project templates, real-time previews, and exportable applications, all served on Cloudflare's global network with integrated observability and caching.
Sep 2025Launching the x402 Foundation with Coinbase, and support for x402 transactionsIntroduces the x402 protocol for machine-to-machine payments, enabling agents to pay for resources directly via HTTP 402 responses. Proposes a new deferred payment scheme for x402, decoupling cryptographic handshake from financial settlement. Integrates x402 support into the Agents SDK and MCP servers, with a playground demo showcasing agentic payments for tools.
Sep 2025Cap'n Web: A new RPC system for browsers and web serversIntroduces Cap'n Web, a new RPC system for JavaScript environments (browsers, Workers, Node.js). It implements an object-capability RPC model, supports JSON serialization, and works over HTTP, WebSocket, and postMessage. Key features include bidirectional calling, passing functions/objects by reference, promise pipelining, and capability-based security. It integrates with TypeScript and has a small footprint. The post provides examples of client and Cloudflare Worker server implementations, highlighting its ease of use and expressiveness.
Sep 2025Bringing Node.js HTTP servers to Cloudflare WorkersThis post introduces the implementation of `node:http` client and server APIs within Cloudflare Workers. The `node:http` client APIs (`http.get`, `http.request`) are built on top of the `fetch()` API. For server APIs, a bridge system connects Node.js-style servers to the Workers request handling model using `handleAsNodeRequest` or `httpServerHandler`, allowing `http.createServer` executions to be registered and invoked via incoming fetch requests, identified by port numbers. This enables compatibility with Node.js frameworks like Express.js and Koa.js.
Aug 2025Cloudflare is the best place to build realtime voice agentsIntroduced Cloudflare Realtime Agents, a runtime for orchestrating voice AI pipelines at the edge. Enabled piping raw WebRTC audio as PCM in Workers, allowing direct connection of WebRTC audio to AI models or media pipelines. Added WebSocket support for Realtime AI inference with models like PipeCat's smart-turn-v2. Integrated Deepgram on Workers AI for speech-to-text and text-to-speech capabilities.
Jul 2025Serverless Statusphere: a walk through building serverless ATProto applications on Cloudflare’s Developer PlatformThis post demonstrates building a serverless ATProto application on Cloudflare's Developer Platform, leveraging Workers, KV, D1, and Durable Objects. It details adapting Rust ATProto libraries for the Workers runtime, handling DID resolution via DNS and KV caching, implementing OAuth flows with session state persisted in KV, fetching user data using an authenticated agent, and publishing updates via the 'create record' operation. It also touches on handling real-time event streams and the challenges of Node.js API compatibility in the Workers runtime.
Jun 2025Orange Me2eets: We made an end-to-end encrypted video calling app and it was easyThis post details the implementation of end-to-end encryption (E2EE) for the open-source Orange Meets video conferencing application, built on Cloudflare Workers and the Cloudflare Realtime SFU. The core contribution is the integration of the Messaging Layer Security (MLS) protocol, compiled to WebAssembly (WASM), to handle group key exchange and establish E2EE for real-time audio and video streams. The implementation involves modifying WebRTC streams to send frames to a Rust web worker for encryption/decryption and addresses codec-specific behaviors (VP8) by sending a small header unencrypted to maintain browser compatibility. The post also discusses the challenges of E2EE in real-time communication compared to text messaging, emphasizing the need for continuous group key agreement protocols like MLS for post-compromise security and perfect forward secrecy.
Jun 2025Building agents with OpenAI and Cloudflare’s Agents SDKThis post details the integration of OpenAI's Agents SDK with Cloudflare's Agents SDK, which leverages Durable Objects for persistent execution. It explains the separation of concerns (OpenAI for cognition, Cloudflare for execution environment) and demonstrates architectural patterns for building AI agents: multi-agent systems, human-in-the-loop workflows, and addressable agents. Key learnings include the importance of state management with Durable Objects, correct routing for agent identity and persistence, and the composability of agents.
Jun 2025Containers are available in public beta for simple, global, and programmable computeThis post introduces Cloudflare Containers, a new beta feature that allows users to run containerized applications globally on Cloudflare's edge network, integrated with Cloudflare Workers. It details the configuration, development workflow (using `wrangler dev` and `wrangler deploy`), built-in observability, and pricing model. The post highlights use cases like code sandboxing, running FFmpeg, and deploying static frontends with containerized backends. It also previews upcoming features like global autoscaling and enhanced inter-container/Worker communication.
Jun 2025We shipped FinalizationRegistry in Workers: why you should never use itThis post introduces the availability of the FinalizationRegistry API in Cloudflare Workers, detailing its purpose in managing external resources tied to garbage-collected JavaScript objects, particularly in the context of WebAssembly memory. It explains the differences in memory management between JavaScript (garbage collection) and WebAssembly (manual management), and demonstrates a pattern for using FinalizationRegistry to bridge this gap. However, it strongly advises against direct use due to the non-deterministic nature of garbage collection and highlights newer JavaScript features as more reliable solutions for preventing memory leaks and ensuring predictable resource cleanup.
Jun 2025Building an AI Agent that puts humans in the loop with Knock and Cloudflare’s Agents SDKThis post details the integration of Knock's messaging infrastructure with Cloudflare's Agents SDK to build an AI agent that incorporates a human-in-the-loop approval workflow for a virtual card issuing process. It demonstrates how to expose tools to the LLM that delegate complex approval logic to Knock, leveraging Knock's workflow engine and Agent Toolkit. The post also covers setting up the chat UI using the Agents SDK's `AIChatAgent` and `useAgentChat` hook, and handling asynchronous approval callbacks via webhooks.
May 2025Let’s DO this: detecting Workers Builds errors across 1 million Durable ObjectsThis post details the development of an automated error detection system for Cloudflare Workers Builds, a CI/CD product built on the Workers platform. It addresses the challenge of identifying and categorizing build failures by analyzing logs stored across over a million Durable Objects. The system uses Workers Queues to process build logs, static patterns, and normalized log lines to detect and group errors, enabling proactive fixes and improving the reliability of the Workers Builds product. It also highlights the 'Customer Zero' approach by using the Developer Platform to build and monitor its own services.
Apr 2025Bringing streamable HTTP transport and Python language support to MCP serversIntroduced Streamable HTTP transport for MCP servers, allowing for bi-directional communication over a single endpoint and backward compatibility with SSE. Enabled Python language support for building MCP servers on Cloudflare Workers using the Python MCP SDK and FastAPI-MCP.
Apr 2025A global virtual private cloud for building secure cross-cloud apps on Cloudflare WorkersIntroduces Workers VPC and Workers VPC Private Links, enabling isolated environments for Workers and Developer Platform resources and bidirectional connectivity to external private clouds. This extends the edge computing capabilities of Cloudflare Workers by providing a global virtual private cloud solution for building cross-cloud applications.
Apr 2025How we simplified NCMEC reporting with Cloudflare WorkflowsThis post details the migration of Cloudflare's NCMEC reporting system from a queue-based architecture using Cloudflare Queues to Cloudflare Workflows. The previous system lacked explicit orchestration, leading to debugging nightmares, unreliable retries, and high operational overhead. The new Workflows-based system provides a single, structured workflow with discrete steps for report creation, file gathering, uploading, metadata addition, and finalization. The Workflows dashboard offers real-time visibility into workflow status, enabling easier troubleshooting and step retries, significantly improving reliability and reducing operational burden.
Apr 2025Simple, scalable, and global: Containers are coming to Cloudflare Workers in June 2025This post introduces Cloudflare Containers, a new capability that allows running containerized applications on the Cloudflare Workers platform. It details how containers can be deployed and managed via Wrangler configuration and Workers code, enabling stateful and stateless workloads. Key technical contributions include the `Container` class for simplified container instantiation and management, integration with Durable Objects for programmable sidecar functionality (start, stop, exec, monitor, state persistence), and the use of Workers for advanced routing, API gateway, and service mesh patterns. Examples demonstrate running untrusted AI-generated code in sandboxed containers and deploying stateless applications like FFmpeg with autoscaling. The underlying architecture leverages Durable Objects to manage container lifecycles and state, providing fine-grained control and enabling advanced use cases.
Apr 2025Startup spotlight: building AI agents and accelerating innovation with Cohort #5This post details how Lamatic AI and Skyward AI leverage Cloudflare Workers, Workers for Platforms, Workers AI, Queues, KV, AI Gateway, Durable Objects, and R2 to build scalable AI agent platforms. Lamatic uses Workers for request processing and scaling, Queues for ETL and event-driven workflows, and KV for secure credential storage. Skyward uses Durable Objects for state management and the new AI agents framework for simplified agent communication, with AI Gateway for inference observability and R2 for long-term storage.
Apr 2025Workers AI gets a speed boost, batch workload support, more LoRAs, new models, and a refreshed dashboardThis post significantly enhances the capabilities of Workers AI by introducing speculative decoding and prefix caching for 2-4x faster inference, an asynchronous batch API to handle large workloads efficiently, and expanded LoRA support for more customized responses. It also recaps new models, updated pricing, and a refreshed dashboard, further solidifying Workers AI as a robust platform for AI inference at the edge.
Apr 2025Make your apps truly interactive with Cloudflare Realtime and RealtimeKitThis post introduces Cloudflare Realtime, a new suite of products for real-time audio and video experiences, and RealtimeKit, a collection of SDKs and server-side services designed to simplify the development of real-time voice, video, and AI applications. It highlights the acquisition of the Dyte team to accelerate RealtimeKit development. The post details how RealtimeKit abstracts WebRTC complexities, offers built-in recording capabilities, and integrates voice AI. It also announces the General Availability of Cloudflare's SFU and TURN services, with SFU now supporting simulcast and TURN offering advanced analytics. A partnership with Hugging Face is also detailed, providing FastRTC users with free TURN bandwidth.
Apr 2025Cloudflare Snippets are now Generally AvailableThis post announces the General Availability (GA) of Cloudflare Snippets, a feature that allows JavaScript code rules to control HTTP traffic at the edge. It details the evolution of Snippets from an idea to a production-grade solution, highlighting key milestones like alpha launch, traffic growth, and the introduction of Terraform support. New features for GA include an enhanced code editor, integration with Trace for debugging, and upcoming integration with Secrets Store. The post also clarifies the distinction between Snippets and Cloudflare Workers, providing use cases for each. The core technical contribution is the productionization and scaling of a JavaScript execution environment within the Cloudflare Ruleset Engine, enabling dynamic traffic manipulation with performance and cost-effectiveness.
Apr 2025Introducing Cloudflare Secrets Store (Beta): secure your secrets, simplify your workflowThis post introduces Cloudflare Secrets Store (Beta), a new centralized platform for managing sensitive values like API tokens and credentials. It integrates with Cloudflare Workers, allowing developers to create account-level secrets that can be shared across multiple Workers, addressing previous friction with per-Worker secrets. The post details the security measures, including encryption and RBAC, and outlines future plans for broader product integration and enhanced management capabilities.
Apr 2025Your frontend, backend, and database — now in one Cloudflare WorkerThis post announces the general availability (GA) of several key features for Cloudflare Workers, significantly expanding its capabilities for full-stack application development. It introduces GA support for multiple frontend frameworks (React Router v7, Astro, Hono, Vue.js, Nuxt, Svelte, Next.js, Angular, SolidJS), the ability to build full-stack apps without a framework using Vite and React, and improved Node.js API compatibility (crypto, tls, net, dns modules). It also highlights the v1.0-beta release of the Next.js adapter (@opennextjs/cloudflare), the GA release of the Cloudflare Vite plugin with Hot Module Replacement, the addition of static _headers and _redirects files, and the ability to connect to MySQL databases via Hyperdrive. Workers Builds now support non-production branches with preview URLs posted back to GitHub. The Images binding is also GA. The post emphasizes Workers as the primary platform for full-stack development, converging capabilities previously found in Cloudflare Pages.
Apr 2025“Just use Vite”… with the Workers runtimeThis post introduces the 1.0 release of the Cloudflare Vite plugin and official support for React Router v7. The core technical contribution is the integration of the Vite dev server with the Cloudflare Workers runtime (workerd) via Vite's new Environment API. This allows server code to run in the native Workers runtime during development, closely matching production behavior. The post details how to create new SPAs and update existing Vite projects using the plugin, including configuration steps and code examples. It highlights the seamless development experience for both client and server code, hot module replacement without state loss, and unified build/preview/deploy workflows. The integration with React Router v7 is also detailed, showcasing how to define the Worker handler in a single file and pass `env` and `ctx` directly to loaders and actions. The post also emphasizes the broad support for the Cloudflare Developer Platform within this integration.
Apr 2025Deploy your Next.js app to Cloudflare Workers with the Cloudflare adapter for OpenNextThis post announces the 1.0-beta release of the Cloudflare adapter for OpenNext, which transforms Next.js applications for deployment on Cloudflare Workers. It highlights the adapter's support for numerous Next.js features, including caching, PPR, middleware, and image optimization, leveraging OpenNext's build tool and test suite. The post also details ecosystem improvements like enhanced Node.js compatibility in Workers and increased Worker size limits. It outlines future development plans for bundle size reduction, performance improvements, and multi-Worker deployments, and provides instructions for deploying a Next.js app to Workers using the new adapter.
Apr 2025Skip the setup: deploy a Workers application in secondsIntroduces the "Deploy to Cloudflare" button, a feature that simplifies the deployment of Workers applications from Git repositories. This button automates repository cloning, provisioning of Cloudflare primitives (KV, D1, R2), configuration of Workers Builds (CI/CD), and the addition of preview URLs for pull requests. It aims to reduce the setup friction for developers sharing open-source Workers projects and for users self-hosting applications.
Apr 2025Cloudflare Workflows is now GA: production-ready durable executionThis post announces the General Availability (GA) of Cloudflare Workflows, a serverless durable execution engine built on Workers. It details the step-based architecture with independent retriability, automatic state persistence, and introduces the `waitForEvent` API for human-in-the-loop and event-driven workflows. The post also highlights integration with the Agents SDK for building AI agents and outlines the pricing model, including new storage pricing.
Apr 2025Piecing together the Agent puzzle: MCP, authentication & authorization, and Durable Objects free tierIntroduced new Agents SDK capabilities for building remote MCP clients with built-in transport and authentication. Added integrations with Stytch, Auth0, and WorkOS for BYO OAuth provider support for MCP servers. Implemented hibernation for McpAgent to manage idle stateful servers. Made Durable Objects available in the free tier. Announced Workflows GA and AutoRAG.
Apr 2025Improve your media pipelines with the Images binding for Cloudflare WorkersIntroduces the Images binding for Cloudflare Workers, enabling programmatic image transformation, overlaying, and encoding directly within the Worker environment. This decouples image optimization from delivery, addresses limitations of the previous fetch-based API for local uploads, and allows for more flexible image processing workflows. The binding supports `.transform()`, `.draw()`, `.output()`, and `.info()` functions. Local development support includes both online (production backend) and offline (mock API) modes. An example demonstrates watermarking and encoding an uploaded image before uploading to R2.
Mar 2025Build and deploy Remote Model Context Protocol (MCP) servers to CloudflareIntroduces the ability to build and deploy remote Model Context Protocol (MCP) servers to Cloudflare Workers. This includes the `workers-oauth-provider` library for OAuth integration, the `McpAgent` class in the Cloudflare Agents SDK for remote transport, the `mcp-remote` adapter for client compatibility, and an AI playground as a remote MCP client. The post details the MCP OAuth flow, the role of the MCP server as an OAuth Provider, and the security benefits of issuing custom tokens.
Mar 2025New URLPattern API brings improved pattern matching to Node.js and Cloudflare WorkersThis post details the contribution of Cloudflare's URLPattern API implementation to Node.js, enhancing interoperability between JavaScript runtimes. It explains the URLPattern API's functionality for URL matching and parameter extraction, its role in the WinterTC Minimum Common API, and the technical work involved in unifying implementations and fixing specification inconsistencies. The post also provides examples of using URLPattern for routing in Cloudflare Workers and discusses future standardization efforts.
Feb 2025Making Cloudflare the best platform for building AI AgentsIntroduced the `agents-sdk` JavaScript framework for building AI agents on Cloudflare Workers. Enhanced Workers AI with JSON mode support, improved tool calling capabilities, and longer context windows. The `agents-sdk` allows for real-time communication, state persistence via Durable Objects, long-running tasks, and integration with React applications via the `useAgent` hook.
Dec 2024The forecast is clear: clouds on e-paper, powered by the cloudThis post details the integration of Cloudflare Workers with a remote browser rendering service (Puppeteer) to fetch, render, and rasterize web content into a bitmap format suitable for display on an ESP32-powered e-paper device. It introduces a three-layer architecture: the ESP32 for display, a Cloudflare Worker for rendering and dithering, and a content server for the original website. The post highlights the practical application of Cloudflare's Browser Rendering API and the implementation of a Floyd-Steinberg dithering algorithm for monochromatic output.
Dec 2024Hi Claude, build an MCP server on Cloudflare WorkersIntroduces the Model Context Protocol (MCP) and demonstrates how to build an MCP server on Cloudflare Workers using the `workers-mcp` tooling. Provides code examples for a basic 'hello world' MCP server and an image generation server utilizing Workers AI. Highlights the simplification of MCP server deployment compared to standard SDKs.
Dec 2024Bring multimodal real-time interaction to your AI applications with Cloudflare CallsThis post details the integration of Cloudflare Calls with OpenAI's Realtime API to enable multimodal real-time interaction with AI applications. It explains how Cloudflare Calls handles the complexity of WebRTC infrastructure (media routing, TURN relays, global availability) allowing developers to integrate AI into video calls. The technical contribution lies in the 'connectHumanAndOpenAI' function, which demonstrates how to route audio tracks bidirectionally between a human's WebRTC session and an AI's session using Cloudflare Calls' API, effectively adding AI participants to video conferences.
Nov 2024DO it again: how we used Durable Objects to add WebSockets support and authentication to AI GatewayThis post introduces WebSocket support for Cloudflare AI Gateway, enabling persistent, authenticated connections to AI providers. It details the use of Durable Objects to manage WebSocket connections, handle asynchronous messages, and correlate requests using `eventId`. Authentication is supported via API tokens in headers or the `sec-websocket-protocol` header for browser compatibility. The implementation reuses existing AI Gateway Universal Endpoint logic for request processing and response formatting, including streaming support.
Oct 2024Workers Builds: integrated CI/CD built on the Workers platformThis post details the architecture and implementation of Workers Builds, a new CI/CD system built on the Cloudflare Workers platform. It describes the design choices, including the use of Durable Objects for scheduling and managing individual builds, a Client Worker with a RESTful API for configuration, and Hyperdrive for secure database access. The post highlights the use of Durable Object storage for build logs and the integration with Cloudflare's container platform for executing build jobs.
Oct 2024Build durable applications on Cloudflare Workers: you write the Workflows, we take care of the restCloudflare Workflows, a durable execution engine for building reliable, repeatable multi-step applications, is now in open beta. It manages retries, metrics, and state persistence without requiring users to manage underlying compute and storage infrastructure. The architecture is built on Cloudflare Workers and Durable Objects, with a configuration API and binding shim implemented as stateless Workers. Account Controllers, dedicated Durable Objects per account, manage workflow configurations and delegate operations to workflow engines powered by SQLite-backed Durable Objects. Steps are the core building blocks, each individually retriable and capable of emitting state, which is then durably stored.
Oct 2024The story of web framework Hono, from the creator of HonoThis post introduces Hono, a web framework built with Web Standards that runs on Cloudflare Workers, Deno, and Bun. It highlights Hono's trie-based router for efficient request handling, its minimal bundle size, and its ability to integrate with Cloudflare bindings (KV, R2, D1) via a context model. The post also showcases Hono's middleware and helper system for extending functionality and discusses its adoption within Cloudflare for core products like D1 and Workers Logs.
Sep 2024Our container platform is in production. It has GPUs. Here’s an early lookThis post introduces Cloudflare's new container platform, built internally to run resource-intensive workloads like AI inference and browser rendering. It details the platform's global scheduling capabilities, which leverage Workers, Durable Objects, and KV to dynamically place containers across Cloudflare's network based on capacity and hardware availability, including GPUs. The platform is runtime-agnostic, supporting gVisor, Firecracker, and QEMU, with ongoing evaluation of cloud-hypervisor. It addresses challenges in scheduling large AI models with specific GPU memory needs and discusses optimizations for image pulling and startup times.
Sep 2024We made Workers KV up to 3x faster — here’s the dataThis post details significant performance optimizations for Workers KV, a key component used by many Cloudflare services. It introduces architectural changes to reduce latency by bypassing intermediary layers (Front Line), implementing tiered cache to minimize requests to storage backends, and adding an in-memory cache for the hottest keys. These optimizations result in up to 3x faster hot reads and up to 20ms faster overall KV operations, directly improving the performance of services like Cloudflare Pages, Queues, and Access.
Sep 2024Builder Day 2024: 18 big updates to the Workers platformThis post announces 18 updates to the Cloudflare Workers platform, many of which are now generally available or in open beta. Key technical contributions include: enabling persistent logs for Workers with a simple `wrangler.toml` configuration, integrating Hyperdrive with Cloudflare Tunnels and Access for secure connections to private databases, making improved Node.js compatibility GA with the `nodejs_compat` flag, enabling static asset hosting directly within Workers for frameworks like Astro and Next.js, and introducing Gradual Deployments for percentage-based traffic rollout. It also highlights GA status for Cloudflare Queues with higher throughput and concurrency, R2 Event Notifications integrated with Queues, and Vectorize improvements. Performance enhancements include up to 3x faster Workers KV and faster Time-to-First-Token for Workers AI. Pricing simplifications are also noted.
Sep 2024TURN and anycast: making peer connections work globallyThis post announces the general availability of Cloudflare Calls TURN service, which leverages Cloudflare's anycast network to provide low-latency, globally distributed TURN servers for real-time communication applications. It details how TURN addresses connectivity and privacy challenges posed by NATs and ICE, and explains Cloudflare's specific implementation using anycast for client-server connections and internal backbone forwarding for relayed addresses to overcome stateful protocol challenges.
Sep 2024More NPM packages on Cloudflare Workers: Combining polyfills and native code to support Node.js APIsThis post introduces a hybrid model for Node.js API compatibility in Cloudflare Workers. It combines native C++ implementations of core Node.js APIs (like Buffer, async_hooks, crypto) within the workerd runtime with build-time JavaScript polyfills (using unenv) for other APIs. This approach allows for broader NPM package compatibility without requiring the `node:` prefix and results in smaller Worker sizes by only polyfilling used APIs. The new `nodejs_compat_v2` flag enables this hybrid model.
Jul 2024Cloudflare Zaraz adds support for server-side rendering of X and Instagram embedsThis post introduces two new Managed Components for Cloudflare Zaraz: X and Instagram embeds. These components enable server-side rendering of social media posts, fetching content via server-side requests (using `manager.fetch` and `manager.useCache` for X, and manipulating HTML for Instagram) and serving it from the user's domain. This approach eliminates client-side JavaScript and cookies, improving privacy, security, and performance. The X embed uses Mustache for templating and caches tweet data for 10 minutes. The Instagram embed manipulates fetched HTML to remove scripts and routes images/CSS through the user's domain. The post also details how to use these embeds by adding placeholder HTML elements and activating the corresponding tools in the Zaraz dashboard.
May 2024Using Fortran on Cloudflare WorkersThis post details the process of compiling and running Fortran code on Cloudflare Workers by leveraging WebAssembly. It introduces the 'Fortiche' toolchain, which uses Flang and Emscripten to compile Fortran to WebAssembly. The post provides a concrete example of a Fortran subroutine for addition, demonstrating how to export functions to JavaScript and manage memory allocation and deallocation within the Worker. It also showcases a more complex example of a handwritten digit classifier using BLAS and LAPACK libraries, highlighting the ability to run scientific workloads at the edge.
Apr 2024Browser Rendering API GA, rolling out Cloudflare Snippets, SWR, and bringing Workers for Platforms to all usersThis post announces the General Availability of the Browser Rendering API for all paid Workers customers, introducing session management for reusing browser instances to improve performance and reduce costs. It also details the phased rollout of Cloudflare Snippets, enabling complex HTTP request/response modifications with JavaScript. The post announces upcoming support for stale-while-revalidate (SWR) cache directive in the second half of 2024 and the general availability of Workers for Platforms on a $25 pay-as-you-go plan, highlighting features like custom limits, tail workers, and outbound workers for platform-level control and observability.
Apr 2024Cloudflare acquires PartyKit to allow developers to build real-time multi-user applicationsThis post announces the acquisition of PartyKit, an open-source platform for real-time, collaborative, multiplayer applications. PartyKit leverages Cloudflare's Durable Objects and WebSockets to simplify the development of stateful serverless applications, making real-time experiences more accessible to developers. It complements existing serverless functions by providing a stateful model that simplifies scalability and reduces costs. The integration aims to enable local-first application development and empower the creation of advanced multiplayer games and collaborative tools.
Apr 2024Blazing fast development with full-stack frameworks and CloudflareIntroduced `getPlatformProxy()` API and Miniflare's magic proxy to bridge Node.js and workerd runtimes, enabling full-stack web frameworks to use Cloudflare's developer platform resources (D1, R2, KV) during local development with framework-specific dev servers. This significantly reduces development iteration latency by allowing developers to leverage framework tooling while accessing simulated Cloudflare services.
Apr 2024We've added JavaScript-native RPC to Cloudflare WorkersIntroduced a JavaScript-native RPC system for Cloudflare Workers, enabling direct method calls between Workers and Durable Objects. This system supports structured clonable types, functions, objects with methods, and byte streams, with zero-latency communication when calls stay within the same thread. It also supports pipelining for multi-step operations within a single network round trip and is built on an object-capability model, leveraging Cap'n Proto under the hood but without requiring schemas.
Apr 2024New tools for production safety — Gradual deployments, Source maps, Rate Limiting, and new SDKsThis post introduces several key features that enhance the production readiness and developer control within the Cloudflare Workers ecosystem. It announces Gradual Deployments, allowing for phased rollouts of code changes to Workers and Durable Objects, complete with version-specific observability and session affinity. It also introduces source-mapped stack traces for more effective debugging of minified code, a new Rate Limiting API for runtime control of API usage, and updates to Durable Objects. These additions empower developers to manage complex, mission-critical applications with greater safety and precision.
Apr 2024Announcing Pages support for monorepos, wrangler.toml, database integrations and more!This post announces several significant improvements to Cloudflare Pages, enhancing its integration with the broader Cloudflare developer platform and improving developer experience. Key contributions include: 1. Monorepo support for Pages CI/CD, allowing for path-based include/exclude controls to manage builds efficiently within monorepos. 2. The introduction of `wrangler.toml` for Pages project configuration, enabling configuration to be stored in source control and managed alongside code. 3. Direct, one-click integrations with several third-party databases (Neon, PlanetScale, Supabase, Turso, Upstash, Xata), simplifying database connectivity for Pages projects. 4. Enhancements to Next.js support, including an ESLint plugin for compatibility checks, `getRequestContext()` APIs for accessing Cloudflare-specific resources, and an overhauled local development workflow.
Apr 2024Cloudflare Calls: millions of cascading trees all the way downThis post details the technical implementation of Cloudflare Calls, a new WebRTC infrastructure service. It explains how Cloudflare leverages its global network and Anycast architecture to act as a single, distributed SFU. Key technical contributions include: using a single IP address for all WebRTC protocols (DTLS, ICE, STUN, SRTP, SCTP) via Anycast, deploying in all Cloudflare data centers, exchanging signaling over HTTP, managing a single PeerConnection per client, and handling dual-stack networking with L4 load balancing for ICE checks. It also discusses the challenges of DTLS packet processing on separate servers from the signaling API and the use of BGP for dynamic client assignment to the nearest data center.
Apr 2024How Picsart leverages Cloudflare's Developer Platform to build globally performant servicesPicsart migrated a critical remote configuration service from a centralized architecture to Cloudflare Workers and Workers KV. This involved redesigning the data storage from a single large blob to approximately 600 smaller KV records (max 10MB each), segmented by platform and country. This optimization reduced the amount of data parsed per request, improving compute duration and overall request latency. The new architecture leverages Cloudflare's global network to bring data closer to end-users, addressing the 1500ms time budget challenge where 50% of devices previously failed to complete requests in time.
Apr 2024Leveling up Workers AI: general availability and more new capabilitiesThis post announces the General Availability (GA) of Workers AI, highlighting significant improvements in performance, reliability, and cost reductions for popular AI models. It details the expansion of GPU deployment to over 150 cities, introduces next-generation hardware plans, and expands the Hugging Face partnership with new models. Crucially, it introduces support for Bring Your Own LoRA fine-tuned inference and enables developers to write Cloudflare Workers in Python, significantly broadening the platform's capabilities for AI and general serverless development.
Apr 2024Bringing Python to Workers using Pyodide and WebAssemblyThis post details the integration of Pyodide into the Cloudflare Workers runtime (workerd), enabling first-class Python support. It explains the lifecycle of a Python Worker, the role of Pyodide as a CPython port to WebAssembly, and the critical use of its foreign function interface (FFI) to bridge Python and JavaScript. The post highlights how Pyodide's dynamic linking capabilities are essential for sharing runtime code footprints across thousands of Workers on a single machine, a key factor in the platform's scalability and cost-effectiveness. It also discusses the technical choices made regarding WebAssembly target triples (Emscripten vs. WASI) and the implications for dynamic linking. The integration allows Python Workers to seamlessly access existing JavaScript APIs and bindings, including Vectorize, Workers AI, R2, and Durable Objects, and import popular Python packages like FastAPI and Langchain.
Apr 2024Why Workers environment variables contain live objectsThis post explains the design and security benefits of Cloudflare Workers bindings, which represent live objects (like KV namespaces or service bindings) rather than simple strings. Bindings improve developer experience by reducing boilerplate and enhance security by preventing SSRF attacks and eliminating the need to manage API keys or certificates directly within the Worker code. The post also discusses a legacy caveat regarding Workers running in front of origins and the future introduction of 'origin bindings' to fully mitigate SSRF.
Mar 2024Improved Cloudflare Workers testing via Vitest and workerdThis post introduces a new Vitest integration for Cloudflare Workers, allowing developers to write unit and integration tests that execute directly within the `workerd` runtime. This enables testing of Worker code, interactions with Cloudflare products (KV, R2, D1, Queues, Service Bindings), and Cron Triggers. The integration uses Vitest's custom pools feature to run the test runner within `workerd`, communicating via WebSockets. It also provides features like hot-module-reloading and per-test isolated storage.
Nov 2023Better debugging for Cloudflare Workers, now with breakpointsThis post introduces and details the implementation of breakpoint debugging for Cloudflare Workers within the `workerd` runtime. It explains how the Chrome DevTools Protocol (CDP) is utilized, specifically the Debugger domain, and addresses the challenge of suspending execution in an event-driven, single-threaded environment by introducing a dedicated I/O thread for handling CDP messages. It also covers the setup for local debugging using Wrangler with VSCode and WebStorm, and the importance of source maps for mapping generated JavaScript back to original source code.
Nov 2023Cloudflare named a leader in Forrester Edge Development Platforms Wave, Q4 2023This post details Cloudflare's recognition as a leader in the Forrester Edge Development Platforms Wave, highlighting the capabilities of its Developer Platform, including Workers, Pages, R2, KV, Queues, Durable Objects, D1, Stream, and Images. It emphasizes how Workers make Cloudflare's network programmable, enabling developers to build distributed applications without deep expertise in distributed systems. Key features discussed include Smart Placement, Hyperdrive for database connection pooling, and Cron Triggers for compute-intensive background work. The post also highlights the expansion into AI with integrated GPUs for Workers AI, support for deploying models from Hugging Face, and the availability of the WebGPU API. It underscores the platform's ease of use, leveraging web standard APIs, TypeScript support, and compatibility with existing JavaScript ecosystem tools. The integration of AI capabilities positions Cloudflare as a competitor to public cloud hyperscalers for various workloads.
Oct 2023Virtual networking 101: bridging the gap to understanding TAPThis post details the technical intricacies of Linux TAP devices, explaining their functionality, setup, and performance tuning. It covers the `tun/tap` interface, device creation via `ioctl` and `/dev/net/tun`, flag options like `IFF_TAP`, `IFF_NO_PI`, and `IFF_VNET_HDR`, and the role of `IFF_NAPI`. It also delves into buffer size management (`txqueuelen`), `virtio_net_hdr` structure, and offloads like `TUN_F_CSUM`, `TUN_F_TSO4`, and `TUN_F_TSO6`, providing practical code examples and insights into potential performance bottlenecks and kernel behaviors.
Sep 2023Hyperdrive: making databases feel like they’re globalThis post introduces Hyperdrive, a new capability for Cloudflare Workers that dramatically speeds up database access. Hyperdrive reduces connection latency by maintaining regional connection pools and caches popular read queries, leading to significant performance improvements (17-25x for cached, 6-8x for uncached queries). It seamlessly integrates with existing database drivers and ORMs by leveraging a modified connection string, allowing developers to connect to various PostgreSQL-compatible databases without rewriting code.
Sep 2023Race ahead with Cloudflare Pages build cachingThis post introduces build caching for Cloudflare Pages, a new feature that significantly reduces build times by storing and reusing dependencies and build outputs. This enhances the CI/CD experience for developers, allowing for faster iterations and deployments, and aligns with the broader evolution of Cloudflare's edge computing capabilities by optimizing the developer workflow.
Sep 2023Re-introducing the Cloudflare Workers PlaygroundIntroduced a revamped Cloudflare Workers Playground with a new VSCode-powered editor supporting multi-module Workers, type-checking, and real-time previews. Enhanced developer tooling with Chrome DevTools integration for logs, network requests, and profiling. Added the ability to share and deploy playground code directly to Cloudflare's global network, focusing on the Worker-as-origin use-case.
Sep 2023Running Serverless Puppeteer with Workers and Durable ObjectsThis post details the integration of the Workers Browser Rendering API with Durable Objects and R2 to create a responsive web design testing tool. It provides code examples for setting up a Worker, Durable Object, and R2 bucket, and demonstrates how to use Puppeteer within a Durable Object to launch persistent browser sessions, take screenshots across multiple resolutions, and store them in R2. The use of Durable Object Alarms is highlighted for keeping browser sessions alive longer and reusing them across requests, thereby improving efficiency and reducing costs associated with session startup.
Sep 2023A Socket API that works across JavaScript runtimes — announcing a WinterCG spec and Node.js implementation of connect()This post announces a significant milestone in the standardization of the connect() API for TCP sockets, a feature initially introduced for Cloudflare Workers. It details the publication of a draft specification by the WinterCG community and a Node.js compatible implementation. This advancement aims to create a unified socket API across JavaScript runtimes, simplifying library development and application deployment by bridging the gap between Workers and Node.js environments.
Sep 2023Cloudflare Integrations Marketplace introduces three new partners: Sentry, Momento and TursoThis post announces the expansion of the Cloudflare Integrations Marketplace with three new partners: Sentry (for observability), Turso (for edge-hosted databases), and Momento (for caching). It details how these integrations simplify connecting Workers to these services by automating credential management and providing SDKs, thereby reducing developer busywork and accelerating application development.
Sep 2023D1: open beta is hereThis post announces the open beta of D1, Cloudflare's native serverless SQL database, highlighting significant scaling improvements with higher per-database storage limits (up to 2GB) and the ability to create many more databases (up to 50,000 per account). It introduces 'Time Travel' for point-in-time database recovery, enabled by default and free of charge. The post also details D1's row-based pricing model, emphasizing cost-efficiency and predictability, and explains how query performance and cost are impacted by indexing. Finally, it positions D1 as a key component for 'Workers for Platforms,' enabling database-per-user isolation for SaaS providers.
Sep 2023New Workers pricing — never pay to wait on I/O againIntroduced a new pricing model for Cloudflare Workers and Pages Functions that bills based on CPU time instead of duration. This change addresses the issue of customers paying for idle time spent waiting on I/O operations. The new model is designed to be more cost-effective, especially for applications with high I/O wait times or long-running AI inference requests. It also includes features for setting maximum CPU time limits per Worker project.
Sep 2023You can now use WebGPU in Cloudflare WorkersIntroduced WebGPU support to Cloudflare Workers by integrating the Dawn library into the workerd runtime. This enables local development and experimentation with WebGPU-enabled workers, allowing for low-level GPU access and general-purpose GPU compute tasks. Access to WebGPU is restricted to Durable Objects to manage stateful GPU operations.
Sep 2023How Waiting Room makes queueing decisions on Cloudflare's highly distributed networkThis post details the evolution of Cloudflare Waiting Room's core queuing mechanism. It explains how the system uses Workers and Durable Objects to make distributed, per-worker decisions on whether to queue traffic or send it to the origin. The article elaborates on the state management, traffic history analysis, and slot allocation strategies employed to minimize latency and prevent origin overload, particularly addressing the challenges of non-uniform traffic distribution across global data centers and workers.
Aug 2023Wasm core dumps and debugging Rust in Cloudflare WorkersThis post introduces the concept and implementation of WebAssembly (Wasm) core dumps and debugging Rust code within Cloudflare Workers. It explains what core dumps are, how they are generated for Wasm (including the use of DWARF), and the current experimental status of Wasm core dump support. Crucially, it details a polyfilling approach using `wasm-coredump-rewriter` to enable core dump generation and debugging for Rust/Wasm in Cloudflare Workers, addressing the lack of native support in the `workerd` runtime.
Aug 2023Hardening Workers KVThis post details recent incidents impacting Workers KV, highlighting issues with its new architecture, deployment processes, and observability gaps. It outlines the root causes, including an observability gap in error reporting and a mutation to local state that resulted in an unexpected mutation of global state. The post also discusses the challenges encountered during progressive rollouts and the impact on specific data centers and regions. It concludes by emphasizing the need for improved deployment strategies, enhanced observability, and a more robust approach to handling unhandled exceptions and state mutations in Workers.
Aug 2023Cloudflare Workers database integration with UpstashThis post introduces the integration of Cloudflare Workers with Upstash databases (Redis, Kafka, QStash) via an OAuth2 flow. It details the setup process within the Workers settings and provides a practical implementation example using Upstash Redis to serve localized greetings based on the `cf-ipcountry` header. It also discusses performance optimizations like Smart Placement and Global Databases.
Jul 2023Cloudflare Zaraz steps up: general availability and new pricingThis post announces the general availability of Cloudflare Zaraz, a product built on Cloudflare Workers. It details Zaraz's functionality in managing third-party tools for data collection, its transition from beta, and introduces a new pricing structure based on 'Zaraz Loads' and feature sets. This marks a significant step in the commercialization and broader adoption of Zaraz, leveraging the underlying Workers platform for server-side processing.
Jun 2023Making Cloudflare Pages the fastest way to serve your sitesThis post details the technical implementation of migrating Cloudflare Pages' asset serving from a large, parsed JSON routing table with regex matching to an O(1) lookup mechanism using Workers for Platforms. The new approach hashes the hostname at runtime to directly identify the correct Worker pipeline, eliminating the latency associated with parsing and iterating through routing tables. The migration strategy involved duplicating deployments, A/B testing, and a phased rollout to ensure minimal customer impact.
Jun 2023Donning a MASQUE: building a new protocol into Cloudflare WARPThis post introduces MASQUE, a new protocol built on HTTP/3 and QUIC, as a replacement for WireGuard in Cloudflare WARP. It highlights MASQUE's advantages in performance, stability, and flexibility due to its standards-based nature and efficient proxying capabilities. The post details how MASQUE leverages Cloudflare's global network and existing infrastructure (like QUIC implementations) to improve user experience and plans for its integration into enterprise Zero Trust products.
Jun 2023Cloudflare Snippets is now available in alphaCloudflare Snippets, built on top of Workers for Platforms, introduces a new phase within the Ruleset Engine for executing user-created JavaScript. Snippets are designed for lightweight tasks like modifying HTTP headers and rewriting URLs, with stricter resource limits (5ms execution, 2MB memory, 32KB package size) compared to full Workers. They run before Workers, allowing for migration of simple logic and enabling conditional execution based on Ruleset Engine filters. Snippets are available across all plan levels with varying limits per zone.
Jun 2023How Kinsta used Workers and Workers KV to improve cache hit rates by 56%This guest post by Kinsta details how they achieved a 56.3% increase in cache hit rates by leveraging Cloudflare Workers and Workers KV. They implemented programmatic customization of cache keys based on domain settings and customer optimization options (like Polish and Auto Minify), and microcached Workers KV data with a 30-second TTL to reduce read operations by 80% and improve responsiveness to client-side configuration changes. This demonstrates a practical application of Workers for advanced caching strategies and efficient data management.
Jun 2023Dynamic data collection with Zaraz Worker VariablesIntroduces Cloudflare Zaraz Worker Variables, a new capability that allows custom JavaScript code to be executed server-side within Cloudflare Workers. This enables dynamic data collection, cleaning, transformation, and enrichment for third-party analytics tools, mirroring functionality previously only available client-side with systems like Google Tag Manager's Custom JavaScript variables. The implementation uses Dynamic Dispatch to call user-defined Workers from the Zaraz Worker, providing context from the Zaraz session and system, and returning results as a Response object. Benefits include improved performance by avoiding client-side roundtrips, isolated execution environments, and secure handling of API secrets.
May 2023D1: We turned it up to 11This post announces a major update to Cloudflare's D1 database, a native serverless SQL database built on SQLite, which is tightly integrated with Cloudflare Workers. Key updates include dramatic improvements to performance and scalability (up to 20x faster reads, 6.8-11x faster writes), a new storage backend, a new console interface for querying, formal support for JSON functions, and the introduction of 'Location Hints' to influence database placement. It also details the upcoming pricing model, which will include an always-free tier and be based on reads, writes, and storage, and announces 'Time Travel' functionality for point-in-time recovery within the last 30 days.
May 2023More Node.js APIs in Cloudflare Workers — Streams, Path, StringDecoderAdds support for Node.js Streams, Path, and StringDecoder APIs to Cloudflare Workers. Introduces the NodeJsCompatModule type for closer Node.js environment emulation. Enables the use of many npm packages that depend on these Node.js APIs directly within Workers.
May 2023Workers Browser Rendering API enters open betaIntroduces the open beta of the Workers Browser Rendering API, enabling programmatic control of headless Chromium instances via the DevTools Protocol. Integrates with Wrangler for deployment and provides a patched, open-source version of Puppeteer (@cloudflare/puppeteer) for easy automation. Demonstrates a screenshotting example Worker. Highlights internal usage for Cloudflare Radar's URL Scanner and outlines future plans for upstreaming Puppeteer changes, supporting Playwright, and exploring WebDriver BiDi.
May 2023Announcing Cloudflare Secrets StoreThis post introduces Cloudflare Secrets Store, a new secrets management offering that addresses the need for a secure, centralized repository for sensitive data. It builds upon the existing secrets management capabilities for Cloudflare Workers by enabling account-level secrets that can be shared across multiple Workers scripts and other Cloudflare services like the WAF. The post details the security measures, including scoped permissions and audit logs, and highlights the benefits for both developers and security administrators.
May 2023Using LangChainJS and Cloudflare Workers togetherThis post demonstrates how to integrate LangChainJS, a framework for building LLM-powered applications, with Cloudflare Workers. It provides a step-by-step guide to setting up a development environment, installing LangChainJS, and building a sample application that fetches and processes data from a Wikipedia article using CheerioWebBaseLoader and Text Splitters. It also introduces the concepts of embeddings and vector stores for understanding text relevance.
May 2023Building Cloudflare on CloudflareThis post details the migration of core Cloudflare services, previously built on NGINX and Lua, to the Cloudflare Workers platform. It explains the architectural shift from a chain of HTTP proxies to a more integrated system leveraging Workers for Front Line (FL) processing. Key motivations include reducing latency overhead, improving developer experience, and enabling isolated deployments. The post outlines the evolution from initial internal worker integrations to the 'Flame' prototype and the subsequent improvements to the developer platform to support internal services, including access to internal services, request logging, state caching, and direct origin requests. It highlights the benefits of using the same tooling as customer-facing Workers and the challenges overcome in enabling internal services to leverage the Workers runtime.
May 2023How Cloudflare is powering the next generation of platforms with WorkersIntroduced three new features for Workers for Platforms: Outbound Workers to intercept and control outgoing fetch() requests from user Workers, Custom Limits to programmatically set CPU time and subrequest caps on user Workers, and Tail Workers to provide real-time logging capabilities for user Workers. These features enhance platform customer control over their users' Worker execution and debugging experience.
May 2023Making Cloudflare the best place for your web applicationsThis post announces the convergence of Cloudflare Pages and Workers into a unified development and application hosting platform. Key advancements include: super low latency global execution, free egress and static asset hosting, a standards-based JavaScript and WASM runtime serving over 10 million requests per second, integration with R2, KV, Queues, and D1, and support for GitOps and CI/CD workflows. It also introduces 'Smart Placement' for Workers, allowing compute to run at optimal network locations (not just the edge) based on data proximity. Wrangler v3 is launched with local-by-default development and improved Chrome DevTools integration. The dashboard editor is upgraded with VSCode and edge preview. Resource limits for applications are increased (10MB bundle size, 400ms startup latency). Pages CI now uses a modern build image with Node.js, pnpm, and build caching. New and improved adapters for frameworks like Next.js, Angular, and Qwik are released, along with the C3 CLI for easy project setup and deployment.
May 2023A whole new Quick Edit in Cloudflare WorkersIntroduced a new Quick Edit experience for Cloudflare Workers within the dashboard, powered by VSCode for Web. This upgrade enables support for multiple JavaScript modules, provides a high-fidelity edge preview by using the same runtime as `wrangler dev`, displays helpful error messages with stack traces, and integrates JSDoc TypeScript syntax for typechecking and autocompletion. The implementation leverages MessageChannel for communication between the dashboard and the VSCode iframe, and has open-sourced key components of the VSCode extension and patches.
May 2023Bringing a unified developer experience to Cloudflare Workers and PagesThis post announces the convergence of Cloudflare Workers and Pages into a single development platform. It details the 'why' behind this integration, highlighting the blurring lines between the two products and the user confusion it caused. The post outlines the vision for a unified platform that combines static asset hosting and serverless compute, integrating with storage products and providing enhanced tooling. It introduces the concept of a 'project' encompassing static assets, serverless functions, and resources. Deployment workflows will leverage GitOps, with preview deployments and environments. Local development will be unified under Wrangler CLI. The benefits of this convergence include performance, cost, and load advantages. The post also details immediate changes, such as a unified creation flow, starter templates, integrated CLI experiences for frameworks, and a merged project list dashboard.
May 2023Modernizing the toolbox for Cloudflare Pages buildsIntroduced a new beta build system for Cloudflare Pages with updated default versions of Node.js, Python, and Ruby, and added support for pnpm. Re-architected the build system from a monolithic Kubernetes container to a modular approach using sequential init containers, improving isolation between system and user stages. This modularity enables future features like build caching. Rearchitected build log streaming to use a global log collector container.
May 2023Improved local development with wrangler and workerdThis post announces Wrangler v3, which makes local-by-default development for Cloudflare Workers a reality by integrating Miniflare v3 powered by the open-sourced `workerd` runtime. This provides a more accurate local testing environment with significant performance improvements (10x faster startup, 60x faster script reloads). It details the architecture of Miniflare v3, its use of SQLite and a separate blob store for flexible storage, and the challenges and solutions for running unit tests within `workerd` processes using WebSockets and Node.js worker_threads. It also covers the effort to make `workerd` cross-platform, including Windows support using clang-cl and Bazel.
May 2023Smart Placement speeds up applications by moving code close to your backend — no config neededIntroduces Smart Placement for Cloudflare Workers and Pages Functions, an automatic feature that optimizes compute resource location based on backend service latency. This addresses the trade-off between bringing compute close to the user versus close to backend resources, particularly for stateful applications interacting with centralized external services. The feature analyzes real-time fetch requests and compares them to network latency data to invoke Workers from optimal data centers, improving application performance by up to 4-8x in tested scenarios. It excludes globally distributed services and analytics/logging requests from optimization.
May 2023Announcing connect() — a new API for creating TCP sockets from Cloudflare WorkersThis post introduces the new `connect()` API for Cloudflare Workers, enabling outbound TCP socket connections. This significantly expands Workers' capabilities by allowing direct connections to any TCP-based service, including databases, which was previously a major limitation. The API is designed to be interoperable and simplifies TLS handling. The post highlights its immediate impact with the integration of the popular `pg` PostgreSQL driver, paving the way for broader database connectivity and full-stack application development on Workers.
Apr 2023Consent management made easy and clear with Cloudflare ZarazThis post introduces Cloudflare Zaraz's new Consent Manager functionality, which leverages Cloudflare Workers to simplify the process of gathering and managing user consent for third-party tools. It addresses the growing need for privacy compliance by providing an opt-in consent modal that respects user choices before scripts are loaded, preventing data loss and avoiding dark patterns. The feature aims to make consent management easy and clear for website owners.
Apr 2023Introducing Rollbacks for Workers DeploymentsIntroduced a rollback feature for Cloudflare Workers deployments, enabling users to revert to previous versions via the dashboard and the `wrangler rollback` command. Enhanced `wrangler deployments list` to show rollback annotations and `wrangler deployments view` to display more detailed deployment metadata (compatibility date, usage model, bindings).
Mar 2023Use the language of your choice with Pages Functions via WebAssemblyIntroduced WebAssembly support for Cloudflare Pages Functions, allowing developers to import and instantiate `.wasm` modules directly from their JavaScript Functions. This enables the use of languages like Rust for server-side logic within Pages Functions, leveraging near-native performance. Also added support for importing raw text and binary modules.
Mar 2023Node.js compatibility for Cloudflare Workers – starting with Async Context Tracking, EventEmitter, Buffer, assert, and utilIntroduced Node.js core API compatibility to Cloudflare Workers, starting with AsyncLocalStorage, EventEmitter, Buffer, assert, and parts of util. These APIs are provided directly by the workerd runtime, eliminating the need for polyfills. The implementation of AsyncLocalStorage is a subset of the Node.js API, omitting brittle features. EventEmitter fully supports the API, including captureRejections. Buffer extends Uint8Array and is compatible with existing Workers APIs. Assert module runs in strict mode. Promisify/callbackify APIs are also supported.
Mar 2023Accelerate building resiliency into systems with Cloudflare WorkersThis post details how Cloudflare Workers were leveraged to build a weighted traffic routing module for email service providers. This solution significantly improved the resiliency of Cloudflare's email notification systems by enabling rapid failover between vendors, thus preventing outages caused by external ESP failures and ensuring timely delivery of critical emails. The implementation minimized code changes in existing services and provided near-instantaneous deployment of configuration updates.
Mar 2023Oxy is Cloudflare's Rust-based next generation proxy frameworkThis post introduces Oxy, a new Rust-based proxy framework that serves as a foundation for several Cloudflare projects, including the Zero Trust Gateway and iCloud Private Relay's second hop proxy. Oxy enhances Cloudflare's edge computing capabilities by providing a programmable, highly customizable, and extensible proxy server that can handle massive amounts of traffic. It allows engineers to control every aspect of proxying, from protocol decapsulation to DNS resolution, and integrates with surrounding infrastructure for telemetry and networking services. Its extensibility model is similar to Cloudflare Workers, enabling developers to build sophisticated applications with minimal code.
Mar 2023How we built an open-source SEO tool using Workers, D1, and QueuesThis post showcases the use of Cloudflare Workers in conjunction with new developer tools like D1 and Queues to build an open-source SEO monitoring tool called Prospector. It highlights how Workers serve as the user-facing API and coordinator, D1 for data storage, and Queues for handling background tasks like URL fetching and notifications. The post also emphasizes the improved developer experience with enhanced TypeScript bindings and the Hono framework for API development, demonstrating the platform's capability for building production-ready applications.
Feb 2023How Rust and Wasm power Cloudflare's 1.1.1.1This post details the development of BigPineapple, a new Rust-based recursive DNS resolver that replaces Knot Resolver for the 1.1.1.1 service. It addresses limitations in the previous system, including blocking I/O in Lua plugins, inefficient cache space utilization, and module isolation issues. BigPineapple utilizes Tokio for its async runtime, a redesigned module system, and an updated I/O architecture with a frame abstraction and a conductor component for managing outbound connections. The new system aims to improve performance, cache efficiency, and module isolation.
Feb 2023So long, and thanks for all the deployments: deprecating Wrangler v1This post announces the deprecation of Wrangler v1 and the full transition to Wrangler v2. It details the reasons for the rewrite (maintainability and complexity of v1), the improvements in v2 (offline development, zero-config startup, developer tools support), and the migration process for users. It also highlights the success of v2 surpassing v1 in downloads.
Feb 2023Welcome to Wildebeest: the Fediverse on CloudflareThis post introduces Wildebeest, an open-source, easy-to-deploy ActivityPub and Mastodon-compatible server built entirely on Cloudflare's Supercloud. It details the architecture, which leverages Cloudflare Pages for deployment and Pages Functions for running code, similar to Cloudflare Workers. The implementation uses D1 for data storage, Qwik for its web frontend, and integrates with other Cloudflare products like KV, R2, and Durable Objects. The post highlights the use of file-based routing in Pages Functions, unit testing with Jest, and the Qwik City framework for the frontend. It also discusses challenges faced with D1's SQLite backend regarding UUID storage and performance.
Nov 2022Doubling down on local development with Workers: Miniflare meets workerdIntroduced Miniflare 3, powered by the open-sourced `workerd` runtime, providing bug-for-bug compatibility with the Cloudflare Workers production environment. This significantly reduces behavior mismatches and simplifies local development. Added experimental opt-in support for accessing real Workers KV namespaces locally. Announced that `wrangler dev --local` will become the default, offering substantial reductions in startup and script reload times. Introduced `wrangler init --from-dash` to easily set up local projects from existing dashboard-developed Workers.
Nov 2022Improving Workers TypeScript support: accuracy, ergonomics and interoperabilityThis post details significant improvements to the automatic generation of TypeScript types for Cloudflare Workers. Key contributions include: rebuilding generation scripts for accuracy and ease of use, open-sourcing these scripts, generating separate type versions for improved interoperability with browser/standard types (e.g., Remix frameworks), enabling selection of types based on compatibility dates, integrating Wrangler configuration (`wrangler.toml`) for automatic ambient type generation (KV namespaces, R2 buckets, module rules), and embedding documentation directly into types. The underlying generation process now uses `workerd`'s RTTI system and the TypeScript Compiler API, with handwritten overrides for higher-fidelity types (generics, method overloads, renaming, etc.).
Nov 2022Twilio Segment Edge SDK powered by Cloudflare WorkersThis post details the development of the Segment Edge SDK, which leverages Cloudflare Workers to solve challenges in first-party data collection and real-time personalization. It explains how the SDK injects analytics.js snippets into web pages using HTMLRewriter, proxies Segment CDN and API endpoints to first-party domains, and sets HTTPOnly cookies to maintain user identity. The technical implementation involves a router within the Worker to match request URLs and execute specific handlers for asset proxying, event forwarding, and HTML enrichment.
Nov 2022Spice up your sites on Cloudflare Pages with Pages Functions General AvailabilityThis post announces the general availability of Cloudflare Pages Functions, which are specialized Cloudflare Workers. It details improvements in the developer experience, including Git-based deployment, direct upload of Functions, enhanced debugging with `wrangler pages deployment tail`, and real-time metrics in the dashboard. It highlights integrations with storage bindings (Workers KV, Durable Objects, R2, D1) and secret bindings. The introduction of Pages Plugins for third-party services (Sentry, Honeycomb, Stytch, MailChannels) and expanded framework support (Next.js 13, Remix, SvelteKit, QwikCity, SolidStart, Astro, Nuxt) are also covered. The post clarifies that Functions are essentially Workers and explains the scaling and billing model, which aligns with Workers paid subscriptions, offering unlimited dynamic requests on paid plans.
Nov 2022How we built it: the technology behind Cloudflare Radar 2.0This post details the engineering approach to building Cloudflare Radar 2.0, highlighting the use of Cloudflare Pages with Functions for server-side rendering and API serving, Remix for full-stack application development on the edge, and a Python/FastAPI backend API communicating with a Workers-based frontend API via GraphQL. It showcases how Cloudflare's own products are used to build complex applications, emphasizing ease of development, performance optimization, and scalability.
Nov 2022Incremental adoption of micro-frontends with Cloudflare WorkersIntroduced 'fragment piercing', a technique to incrementally integrate server-side rendered micro-frontend fragments into legacy client-side rendered applications. Demonstrated this with a 'productivity suite' demo using React, Qwik, and SolidJS fragments, showcasing improved initial load times and interactivity by rendering fragments before the legacy application shell boots up.
Nov 2022Keep track of Workers’ code and configuration changes with DeploymentsIntroduced Deployments for Cloudflare Workers, a feature that tracks changes to Worker code, configuration, and bindings. Deployments log the author, source (Wrangler, API, dashboard, Terraform), and timestamp of each change. This information is accessible via the Cloudflare dashboard and the `wrangler deployments` command. The feature is currently in open beta and future plans include automated deployments, rollbacks, and version control integration.
Nov 2022Server-side render full stack applications with Pages FunctionsThis post announces the general availability of Cloudflare Pages Functions, which leverage Cloudflare Workers to enable server-side rendering (SSR) for full-stack applications deployed on Cloudflare Pages. It details how Pages Functions allow dynamic computation within 50ms of 95% of users globally, improving Time To Interactive (TTI) and SEO rankings compared to client-side rendering. The post provides integration guides and examples for popular frameworks like QwikCity, Astro, SolidStart, and Nuxt.js, demonstrating how to configure their adapters and build processes to deploy SSR applications to Pages Functions.
Nov 2022The most programmable Supercloud with Cloudflare SnippetsIntroduced Cloudflare Snippets, a new feature integrated into the Ruleset Engine, allowing users to execute small code snippets (JavaScript, VCL, .htaccess) for traffic modifications. Snippets have a 5ms execution time, 2MB memory limit, and 32KB package size, and are available at no additional cost for most plans. They can be triggered by Ruleset Engine filters and run alongside other rules. Snippets are designed for simpler use cases than Cloudflare Workers, such as header modification, URL rewriting, and traffic routing, and include migration tools for VCL and .htaccess files.
Nov 2022UPDATE Supercloud SET status = 'open alpha' WHERE product = 'D1';This post announces the open alpha of D1, a global relational database built on Cloudflare Workers. It details how developers can interact with D1 through the dashboard and Wrangler CLI, including executing SQL files and managing migrations. It also highlights the integration of D1 with Workers and Pages Functions for building full-stack serverless applications. Additionally, it showcases community-contributed tooling for D1, such as d1-orm, workers-qb, d1-console, and a Kysely adapter, and outlines current limitations in testing, such as replication and JavaScript transaction support.
Nov 2022Bringing authentication and identification to Workers through Mutual TLSThis post announces the upcoming introduction of mutual TLS (mTLS) authentication for outbound requests from Cloudflare Workers. It highlights the limitations of current service-to-service authentication methods like Authenticated Origin Pull and token authentication, emphasizing the need for granular, secure, and identity-aware communication. The new mTLS feature will allow Workers to present client certificates, enabling servers to validate the identity of the specific Worker making the request, thus enhancing security and simplifying management for inter-service communication.
Nov 2022Automate an isolated browser instance with just a few lines of codeIntroduces the Workers Browser Rendering API, a new capability that allows developers to run browser automation frameworks like Puppeteer within Cloudflare Workers. This enables programmatic browser interactions such as taking screenshots, performing E2E testing, and performance testing. The API leverages remote browser isolation technology, providing disposable, sandboxed browser instances per request, secured by gVisor and seccomp profiles. It integrates with existing Worker bindings and can save output to R2. Bot Management signals are included to detect Worker-based Puppeteer requests.
Nov 2022Making static sites dynamic with Cloudflare D1This post introduces Cloudflare D1, a serverless SQL database, and demonstrates its integration with Cloudflare Workers. It showcases how D1 can be used to add dynamic, relational data capabilities to static sites, enabling the creation of comments APIs and other data-driven features without requiring developers to manage database infrastructure. The post details the process of setting up a D1 database, configuring bindings in wrangler, and interacting with the database using SQL commands and within Workers functions.
Nov 2022Xata Workers: client-side database access without client-side secretsThis post details Xata's implementation of Xata Workers using Cloudflare Workers for Platforms. Key technical contributions include: using Worker Namespaces to group and encapsulate functions, creating Worker Scripts with unique names and compilation identifiers, injecting database connection details during compilation to restrict access scope, and implementing a Dispatcher function for routing requests, configuring CORS headers, and managing log drains. It also highlights the use of KV Namespace for caching query results and the use of Miniflare for local development emulation.
Nov 2022Get started with Cloudflare Workers with ready-made templatesIntroduces a collection of ready-made templates for Cloudflare Workers, simplifying project setup and showcasing various use cases. Features include a 'Deploy with Workers' button for quick deployment via GitHub Actions, integration with Vitest for Test Driven Development using Wrangler's unstable_dev API, and an 'Open with StackBlitz' button for browser-based development environments. The post also details a template for an image sharing website with Pages Functions, direct creator uploads to Cloudflare Stream, and a Durable Object-powered request scheduler, as well as a payment processing example using Pages Functions, Cloudflare Stream, and Stripe Checkout.
Nov 2022Easy Postgres integration on Cloudflare Workers with Neon.techThis post introduces a new integration for Cloudflare Workers with Neon.tech, a serverless PostgreSQL provider. It addresses the challenge of connecting Workers to databases by leveraging a WebSocket proxy and a specialized client library (`@neondatabase/serverless`) that shims Node.js features not present in Workers. This enables developers to easily use PostgreSQL within their Workers, including advanced use cases like geospatial queries with PostGIS, and demonstrates how to provide connection details and write Worker code for database interaction.
Nov 2022Cloudflare Workers scale too well and broke our infrastructure, so we are rebuilding it on WorkersThis post details how DevCycle rebuilt its infrastructure on Cloudflare Workers to handle extreme load spikes that overwhelmed their traditional AWS infrastructure. It describes moving event processing to a new Cloudflare Worker and Kinesis Data Firehose, and discusses architectural considerations for data management within Workers, including KV, Durable Objects, R2, and D1, highlighting the predictable cost structure of Workers. The post also mentions the use of WASM libraries for consistency across SDKs.
Nov 2022The road to a more standards-compliant Workers APIThis post details Cloudflare's participation in the WinterCG and the subsequent improvements made to the Workers runtime to align with the Minimum Common Web Platform API. Specifically, it highlights the enhanced implementations of Event and EventTarget, including support for subclassing, one-time handlers, cancelable handlers via AbortSignal, and event listener objects. It also introduces the implementation of AbortController and AbortSignal for task cancellation, and mentions ongoing work to align with standards for text encoding/decoding, URL parsing, and streams.
Oct 2022And here's another one: the Next.js Edge Runtime becomes the fourth full-stack framework supported by Cloudflare PagesThis post details the integration of Next.js' Edge Runtime with Cloudflare Pages. It explains how the `@cloudflare/next-on-pages` CLI transforms Next.js projects to run on Cloudflare Workers, leveraging the Build Output API. It also covers the use of compatibility dates and flags for runtime versioning and the experimental webpack minification for optimizing script size. The post provides a step-by-step guide for deploying a Next.js application with the Edge Runtime.
Oct 2022Cloudflare Workers and micro-frontends: made for one anotherIntroduces a 'fragments architecture' for building micro-frontends using Cloudflare Workers. This architecture leverages multiple, independently deployable Workers to server-side render fragments of a web page in parallel. The post details the benefits of this approach, including encapsulation, composability, improved Lighthouse scores, and eager interactivity. It highlights the use of Qwik as a suitable framework for this architecture and provides a demo application ('Cloud Gallery') as a proof of concept.
Sep 2022Introducing workerd: the Open Source Workers runtimeIntroduced workerd, an open-source runtime based on the same code powering Cloudflare Workers. workerd is designed for self-hosting Workers applications, realistic local development and testing (integrating with Miniflare and Wrangler), and programmable proxies. It emphasizes a server-first, event-driven architecture, web standard APIs, nanoservices (running multiple Workers isolates within a single process for low-latency communication), homogeneous deployment (running every service on every machine), and capability bindings for cleaner configuration and SSRF safety.
Sep 2022Cloudflare Queues: globally distributed queues without the egress feesThis post introduces Cloudflare Queues, a new globally distributed message queuing service that integrates directly with Cloudflare Workers. It enables reliable, at-least-once message delivery, supports batching for efficient processing, and crucially, eliminates egress fees for message data. The post details how Queues function as a foundational building block for more complex and reliable applications on the Developer Platform, allowing developers to defer tasks, scale processing, and decouple services.
Sep 2022D1: our quest to simplify databasesThis post introduces D1, Cloudflare's first SQL database designed to work with Cloudflare Workers, enabling developers to build full-stack applications entirely on Cloudflare's global network. It highlights the seamless integration with Wrangler for database creation, bootstrapping, and local development. The post also details automatic backup and restore capabilities, dashboard management, and a significant upcoming feature: JavaScript transactions implemented via stored procedures to address the challenges of distributed transactions in a serverless environment.
Sep 2022Securing the Internet of ThingsThis post introduces the application of Cloudflare Workers and the broader Cloudflare platform to the Internet of Things (IoT) space. It highlights the development of an IoT platform that provides device management, cellular connectivity provisioning, and robust security. Key contributions include leveraging Workers for offloading authentication and compute, using API Shield for securing device communication, and extending Cloudflare Gateway for policy-based control of IoT device network traffic. The post also emphasizes moving compute off resource-constrained IoT devices to the edge via Workers, Analytics Engine, D1, and Pub/Sub, thereby reducing device cost and complexity while enhancing security and enabling faster iteration.
Sep 2022Going originless with Cloudflare Workers – Building a Todo app – Part 1: The APIThis post introduces the use of Custom Domains for Cloudflare Workers, enabling originless applications. It details the architecture for a todo list API, comprising a gateway Worker, individual Workers for CRUD operations (list, create, get, update, delete), and D1 database bindings for persistence. The post provides code examples for D1 database setup and schema, individual endpoint Worker implementations, and the API gateway Worker's routing logic. It also demonstrates the `wrangler.toml` configuration for D1 bindings and Service Bindings to connect the gateway to endpoint Workers, and the deployment process using `wrangler publish`.
Sep 2022The easiest way to build a modern SaaS applicationIntroduces Workers for Platforms, a new offering that extends Cloudflare Workers to SaaS businesses. Key new features include Dispatch Workers for routing and logic execution, User Workers for end-developer customization, unlimited scripts per customer, and Dynamic Dispatch Namespaces for ad-hoc Worker communication. The post details the architecture and provides code examples for implementing Dispatch Workers and uploading User Workers via API.
Sep 2022Ethereum Gateway support for Görli + Sepolia Testnets and the Ethereum MergeThis post details the integration of Cloudflare Workers into the Ethereum Gateway architecture to handle JSON-RPC calls, ensuring geographic region-specific processing and request normalization. It also describes the addition of a consensus client to the Ethereum Nodes to prepare for the Ethereum Merge and the addition of support for Sepolia and Görli testnets, allowing customers to interact with these testnets via the Ethereum Gateway.
Aug 20221.1.1.1 + WARP: More features, still privateThis post details significant enhancements to the 1.1.1.1 + WARP apps, focusing on improving the user experience by providing geographically accurate browsing without compromising privacy. It introduces a new mechanism to ensure relevant search results and content access by replacing user IP addresses with geolocated Cloudflare egress IPs. Additionally, it announces an expansion of the WARP+ network to over 275 cities, offering improved speed and lower latency for subscribers. The post also reiterates the commitment to privacy by not requesting specific location permissions or logging user IP addresses.
Aug 2022Build your next big idea with Cloudflare PagesThis post announces the general availability of Cloudflare Pages, a platform for deploying static sites and serverless functions. It highlights unlimited requests, bandwidth, free seats, and projects, along with integrations with Cloudflare Workers, Access, custom domains, and Web Analytics. It also mentions future integrations with R2 and D1, positioning Pages as a key component of a full-stack edge platform.
Aug 2022Building a scheduling system with Workers and Durable ObjectsThis post details the construction of a scalable scheduling system using Cloudflare Workers and Durable Objects. It introduces a new pattern for managing scheduled HTTP requests by leveraging Durable Objects, each with its own storage and alarm scheduler. The system allows for creating, updating, and potentially managing scheduled requests via a simple API, demonstrating the practical application of Durable Objects for event-driven architectures and reliable task execution at the edge.
Aug 2022Building and using Managed Components with WebCMThis post introduces Managed Components and WebCM, an open-source reference implementation of a Component Manager. Managed Components allow third-party tools to integrate with websites using a permissions system, running code server-side rather than in the browser. WebCM acts as a proxy to run these components, offering improved performance, security, and privacy. The post details how to set up WebCM and configure it to load components like a demo component and Google Analytics, demonstrating server-side execution and event tracking.
Aug 2022Running Zig with WASI on Cloudflare WorkersThis post details the process of compiling Zig code to WebAssembly with WASI support and deploying it on Cloudflare Workers using wrangler2. It demonstrates a 'Hello, World!' style program that reads from stdin and writes to stdout, showcasing the seamless transition from local execution to a deployed Worker without code modifications. The key technical contribution is the demonstration of Zig's WASI compilation target (`wasm32-wasi`) and its direct compatibility with Cloudflare Workers.
Jul 2022A story about AF_XDP, network namespaces and a cookieThis post details the debugging and resolution of a crash in flowtrackd, a DDoS defense daemon, which occurred when creating a second AF_XDP socket within a different network namespace. The root cause was identified as an interaction between AF_XDP, network namespaces, and the shared UMEM feature, specifically when interface index numbers conflicted across namespaces. A fix was implemented by ensuring unique interface index numbers, allowing the shared UMEM feature to function correctly for high-performance packet processing within isolated network environments.
Jul 2022Announcing support for WASI on Cloudflare WorkersIntroduced experimental support for WASI on Cloudflare Workers, enabling the execution of WASI-compiled WebAssembly binaries. Updated Wrangler2 to support WASI compilation and deployment. Provided examples of deploying CLI applications like 'hexyl', 'swc', and 'zstd' as cloud services. Included boilerplate for invoking WASI modules from JavaScript Workers.
Jun 2022Cloudflare Zaraz launches new privacy features in response to French CNIL standardsIntroduced new privacy features for Zaraz: removal of URL query parameters, hiding originating IP addresses (configurable per tool or globally), clearing user agent strings for server-side integrations, and removal of external referrers. Provided a detailed guide on configuring Zaraz with Google Analytics to meet French CNIL standards, emphasizing server-side loading, IP anonymization, and cleaning specific Google Analytics configurations to avoid personal data collection.
May 2022Network performance update: Platform WeekThis post provides updated performance benchmarks for Cloudflare Workers against Fastly's Compute@Edge, detailing a revamped measurement methodology that includes expanding the number of measured networks from 1,000 to 3,000 and introducing 'Wait time' as a metric alongside Time to First Byte (TTFB). It also details the specific JavaScript and Rust functions used for testing compute actions and discusses the removal of the "no benchmarking" clause from the Terms of Service.
May 2022Route to Workers, automate your email processingIntroduces the 'Route to Workers' feature for Cloudflare Email Routing, allowing incoming emails to be processed by Cloudflare Workers. This adds a new `email` event handler to Workers, providing access to email fields, headers, and body. It also includes starter templates for common email processing use cases and integrates with the Email Routing dashboard for easy creation and management. The feature offers a free tier of 100,000 Worker requests per day.
May 2022Announcing Pub/Sub: Programmable MQTT-based MessagingThis post introduces Cloudflare Pub/Sub, a programmable message bus built on MQTT, as a new capability for the Cloudflare Developer Platform. It allows developers to publish and subscribe to messages, filter, aggregate, and modify them using Cloudflare Workers before distribution. This enables real-time messaging, event routing, and moving logic to the edge, complementing existing Workers features like KV, Durable Objects, and R2 for building full-stack applications.
May 2022Introducing Custom Domains for WorkersIntroduces Custom Domains for Cloudflare Workers, allowing users to map a domain directly to a Worker. This feature leverages Cloudflare DNS to register the Worker as the origin, automatically handling DNS records and certificate issuance. It simplifies the developer experience by treating the custom domain as the origin server, enabling direct service calls via bindings and increasing the external request limit for Unbound usage to 1,000. It also allows Workers to invoke other Workers via standard HTTP requests.
May 2022Introducing Pages PluginsIntroduced Pages Plugins, a new feature for Cloudflare Pages that allows developers to incorporate reusable, customizable runtime code modules (Plugins) into their Pages applications. Plugins function as composable Pages Functions, inheriting their capabilities like middleware, parameterized routes, and static assets. The post details the installation and mounting process for Plugins, provides an example for a hypothetical logger plugin, and highlights official launch partners (Sentry, Honeycomb, Stytch) with code examples. It also mentions other built-in plugins (Google Chat, Cloudflare Access, Static forms, GraphQL) and encourages community contributions.
May 2022Announcing D1: our first SQL databaseThis post announces the launch of D1, Cloudflare's first SQL database, specifically designed for Cloudflare Workers. It highlights D1's foundation on SQLite, its serverless nature, and its potential for building various applications like APIs, eCommerce sites, and CRMs. The post details the developer experience, including easy database creation, integration with Workers via bindings, and the use of Wrangler 2. It also outlines future features such as read replication, batching, embedded compute, automatic backups to R2, and import/export capabilities, further enhancing the stateful capabilities of the Workers platform.
May 2022Durable Objects Alarms — a wake-up call for your applicationsThis post introduces Durable Objects Alarms, a new capability for Durable Objects within the Cloudflare Workers ecosystem. Alarms allow Durable Objects to schedule their own future execution via an `alarm()` handler, providing guaranteed at-least-once execution and enabling use cases like queues and deferred processing. This significantly enhances the fault tolerance and programmatic control of Durable Objects, complementing the existing edge computing capabilities of Workers.
May 2022Announcing Workers for Platforms: making every application on the Internet more programmableIntroduces 'Workers for Platforms,' a tool suite enabling businesses to make their applications programmable by allowing customers to run custom logic (Workers) directly within the platform. This addresses the limitations of APIs by providing lower-level primitives. Key features include APIs for managing Workers at scale (hundreds of thousands to millions), tags for bulk actions (e.g., account deletion cleanup), 'Trace Workers' for debugging and logging customer Worker executions, and 'Dynamic Dispatch' for chaining platform-owned Workers with customer-owned Workers. This enables platform providers to design tailored developer experiences.
May 2022Service Bindings are generally available, with efficient pricingIntroduced Service Bindings, a new API for direct Worker-to-Worker communication within the Cloudflare Workers runtime. This enables segmentation of application logic across multiple Workers, improving composability and enabling granular deployments. The post details an API Gateway example using Service Bindings to route requests to other Workers for authentication and data retrieval. It also highlights a new cost efficiency model where billing duration is consolidated across all Workers triggered by a single incoming request, eliminating charges for idle resources and contrasting it with traditional serverless models.
May 2022A new era for Cloudflare Pages buildsThis post details significant improvements to the Cloudflare Pages build experience, a platform leveraging Cloudflare Workers. Key updates include a new build infrastructure that drastically reduces build initialization time (from 2+ minutes to 2-3 seconds) by using pre-warmed machines and gVisor for secure sandboxing. It also introduces real-time build log streaming for faster debugging and provides granular control over branch deployments, allowing users to specify included/excluded branches and use a 'CI Skip' command. Future plans for Pages include incremental builds, caching, updated build images, and improved error messaging.
May 2022Introducing Direct Uploads for Cloudflare PagesIntroduced direct uploads for Cloudflare Pages, allowing developers to bypass integrated CI pipelines and deploy build artifacts directly. This supports various source control providers (including non-Git like SVN/Mercurial) and custom CI tools. Developers can now use the Wrangler CLI (`npx wrangler pages publish <directory>`) or drag-and-drop assets into the dashboard to create new projects and subsequent deployments. This feature enhances flexibility for complex build scenarios and self-hosted repositories.
May 2022A Community Group for Web-interoperable JavaScript runtimesThis post announces the establishment of the Web-interoperable Runtimes Community Group (WinterCG), co-founded by Cloudflare, Vercel, and Shopify. It highlights the need for standardized web APIs in non-browser JavaScript environments like Cloudflare Workers, Node.js, and Deno, to improve developer code portability and address the limitations of browser-centric standards. The post details the group's goals, including defining a 'Minimum Common Web API' and working on specifications for Web Cryptography Streams and a subset of fetch() for servers, all aimed at maximizing interoperability across these environments.
May 2022Cloudflare and StackBlitz partner to deliver an instant and secure developer experienceThis post introduces a partnership with StackBlitz to bring the Cloudflare Workers development experience directly into the browser using StackBlitz's WebContainers. This enables instant, dependency-free development environments for Workers applications, powered by WebAssembly. It highlights improvements to Wrangler to support running in Node.js environments, including the browser. The post also showcases new templates for creating Workers applications (router, durable-objects, typescript) and discusses future plans to enable full developer lifecycle features within the browser, such as authentication, edge development, publishing, and debugging.
May 202210 things I love about Wrangler v2.0This post announces the general availability of Wrangler v2.0, a complete rewrite of the CLI for building Cloudflare Workers. Key improvements include: simplified installation via the `wrangler` npm package, zero-configuration startup, a one-liner `wrangler init` command for project setup, a `--local` development mode powered by Miniflare, on-demand log tailing (`wrangler tail`), enhanced error and warning messages, on-demand debugging tools (hotkey 'D'), native npm module support, and experimental Node.js compatibility mode. The rewrite also addresses hundreds of outstanding issues and bugs from the previous version.
May 2022Open source Managed Components for Cloudflare ZarazIntroduced Managed Components as a new format for third-party tools within Cloudflare Zaraz, enabling server-side execution, permission-based controls, and same-domain asset serving. This shifts execution from the browser to a server-side Components Manager, improving security, performance, and privacy. Announced WebCM, an open-source reference implementation of the Managed Components API, and plans to open-source initial Managed Components.
May 2022The next chapter for Cloudflare Workers: open sourceThis post announces the open-sourcing of the Cloudflare Workers runtime under the Apache-2.0 license. This addresses developer concerns about vendor lock-in and the desire for local development environments. The runtime was built with specific security and performance guarantees for a multi-tenant edge environment, diverging from traditional server-side JavaScript and leveraging the Service Workers API model.
May 2022Cloudflare Relay WorkerThis post introduces a new Cloudflare Worker that acts as a relay to transform generic webhook payloads from Cloudflare's Notification Center into formats compatible with other services, specifically demonstrating integration with Rocket Chat. It provides a step-by-step guide on cloning a GitHub repository, configuring secrets and URLs, modifying the worker code to handle authentication and payload transformation, and deploying the worker. This enhances the flexibility of the notification system by enabling integration with any service that accepts webhooks.
Feb 2022Need to keep analytics data in the EU? Cloudflare Zaraz can offer a solutionThis post introduces Cloudflare Zaraz, a third-party manager built on Cloudflare Workers, designed to address GDPR and Schrems II compliance concerns related to data transfers to the US. Zaraz offloads third-party tool execution from the browser to the Cloudflare Workers platform, enabling features like IP address masking for tools such as Google Analytics and Facebook Pixel/Conversion API. It also includes a Data Loss Prevention (DLP) feature to scan and mask sensitive data. For Enterprise customers, Zaraz can be integrated with Cloudflare's Regional Services and Customer Metadata Boundary to ensure data localization within the EU.
Jan 2022A Workers optimization that reduces your billIntroduced an optimization to the Cloudflare Workers runtime that stops billing for 'in use' time once response headers are forwarded and no further application code executes. This change applies to HTTP proxies, WebSocket proxying, reading from cache, and streaming from KV, resulting in an average 70% reduction in billed 'in use' time for Workers Unbound customers. This optimization is invisible to application code and is applied automatically.
Jan 2022Miniflare 2.0: fully-local development and testing for WorkersMiniflare 2.0 is released, offering a fully-local development and testing environment for Cloudflare Workers. Key improvements include modularity (splitting components into separate packages), a lightweight design (reducing dependencies and install size), and increased accuracy in replicating the Workers runtime. It introduces live-reload features and first-class support for Jest testing. Miniflare 2.0 is integrated into Wrangler 2.0, simplifying local development workflows.
Dec 2021Supporting Remix with full stack Cloudflare PagesThis post details the integration of the Remix framework with Cloudflare Pages, enabling full-stack applications to run at the edge. It highlights Remix's native compatibility with Cloudflare Workers, its focus on web fundamentals, and the performance benefits of edge deployment over traditional server-based Node.js processes. The post also outlines how Remix applications can leverage Cloudflare's data storage options like KV and Durable Objects, and other Workers features such as geolocation, HTMLRewriter, and Cache API. Deployment instructions for Remix on Cloudflare Pages are provided, emphasizing the `functions/[[path]].ts` file for serving the Remix application and the `app` folder for application logic. It also mentions the availability of rollbacks and preview deployments, and the `npm run dev` command for local testing with wrangler 2.0 beta.
Dec 2021Zaraz use Workers to make third-party tools secure and fastThis post details how Zaraz, a third-party tool management platform, was built using Cloudflare Workers. It explains the challenges of traditional third-party script execution in browsers (performance impact, security risks, data privacy concerns) and how moving this execution to the edge with Workers provides benefits such as faster website loading, better control over data sent to third parties, and continuous verification of code integrity. The post highlights the specific requirements that led to choosing Workers (JavaScript execution, security, programmability, speed, global distribution) and demonstrates a basic Workers implementation for dynamically generating JavaScript.
Nov 2021Network Performance Update: Full Stack WeekThis post details performance improvements in Cloudflare Workers and the global network. For Workers, it presents benchmark results showing it is 196% faster than Fastly's Compute@Edge based on time to first byte, using a simple function returning request headers. For network performance, it reports an increase in networks where Cloudflare is the fastest provider for TCP Connection Time, reaching 79 new networks (a 14% increase) out of the top 1000 global networks. It provides case studies on improving performance in Peru by addressing uneven traffic distribution and in Sri Lanka by correcting misrouted traffic to Newark, resulting in significant RTT drops and improved rankings in those regions.
Nov 2021Announcing native support for Stripe’s JavaScript SDK in Cloudflare WorkersIntroduced native support for the Stripe Node.js SDK within Cloudflare Workers and Cloudflare Pages. This enables developers to use the Stripe JavaScript library directly, including features like automatic type-checking and simplified function calls, rather than relying solely on the REST API. The post provides code examples for initiating Stripe Checkout sessions and securely validating incoming Stripe webhooks within a Workers function, leveraging `Stripe.createFetchHttpClient()` and `Stripe.createSubtleCryptoProvider()` for compatibility with the Workers runtime.
Nov 2021Launching a Startup on Cloudflare WorkersThis post details the architecture of a startup application (cClip) built on Cloudflare Workers and KV, integrating with Firebase Auth, Firebase Database, RevenueCat, Stripe, and Backblaze B2. It highlights the use of Workers for authentication, authorization, and access control to cloud storage, as well as managing subscription status updates. Challenges and solutions for cross-platform subscriptions and file quota tracking are discussed, emphasizing the role of Workers in validating user identity, subscription status, and authorizing B2 operations. The post also mentions future plans to explore Durable Objects and WebSockets for real-time communication and R2 for storage.
Nov 2021Workers, Now Even More Unbound: 15 Minutes, 100 Scripts, and No Egress FeesThis post announces the removal of egress fees for Workers Unbound and Durable Objects, enabling more affordable data-intensive workloads. It also introduces an increase in CPU time limits for Workers Unbound to 15 minutes via Cron Triggers, allowing for more compute-intensive tasks at the edge. Additionally, the maximum number of deployable Worker scripts per account has been increased to 100, and the platform plans to support larger script sizes, enabling the use of more libraries and new possibilities like running Golang with WASM.
Nov 2021Developer Spotlight: Automating Workflows with Airtable and Cloudflare WorkersThis post details how a developer used Cloudflare Workers and Airtable to automate a complex e-commerce shipping workflow. It highlights the use of Workers for API creation, caching, and integration with third-party services like Shippo and ShipStation. The post also showcases how Airtable's Scripting app can orchestrate these Workers APIs to automate tasks like order triaging, packing slip generation, and sending package details to logistics providers. The development experience and reliability benefits of using Workers for such automation are emphasized.
Nov 2021Cloudflare Pages Goes Full StackThis post announces the integration of Cloudflare Workers with Cloudflare Pages, enabling full-stack application deployment. Developers can now define serverless functions within a `./functions` directory in their Pages project. Pages automatically deploys these functions as Workers during the build process. The post details the file system convention for routing, the use of bindings (KV, Durable Objects, Environment Variables, Secrets), preview deployments for functions, local development with `wrangler` and Miniflare, and integration examples with SvelteKit and server-side rendering.
Nov 2021Developer Spotlight: Chris Coyier, CodePenThis post highlights how CodePen uses Cloudflare Workers for various optimizations, including manipulating HTML before it reaches the user's browser by fetching content from an external CMS and stitching it together. It also details the use of Workers KV for caching results of expensive jobs, avoiding repetitive processing. The post emphasizes the developer experience (DX) of Cloudflare's tooling, noting its 'just-right' amount of features for tasks like crafting clean APIs and accessing KV storage.
Nov 2021Building a full stack application with Cloudflare PagesThis post introduces the integration of Cloudflare Workers Functions within Cloudflare Pages to enable full-stack application development. It details file-based routing for serverless functions, dynamic data handling using KV namespaces and Durable Objects, and the implementation of middleware for access control with Cloudflare Access. The post also demonstrates integration with Cloudflare Images for image uploads and preview URL generation, and outlines the use of Durable Objects for features like download counters. The front-end is built with React and uses SWR for data fetching.
Nov 2021wrangler 2.0 — a new developer experience for Cloudflare WorkersThis post introduces wrangler 2.0, a new generation of developer tooling for Cloudflare Workers. Key improvements include an "out-of-the-box" experience requiring no configuration for a single JavaScript file, automatic bundling and deployment to a development environment with a localhost proxy, and a redesigned live remote debugging experience that feels like local execution. It also introduces a "local mode" powered by Miniflare, allowing Workers to run directly on the developer's machine. The post highlights the beta release and encourages feedback.
Nov 2021Developer Spotlight: James Ross, NodecraftThis post highlights how Nodecraft uses Cloudflare Workers for various use cases, including optimizing websites, handling redirects, image content negotiation (serving AVIF and JPEG XL), and powering high-traffic JSON APIs (PlayerDB, MCUUID, SteamID) that receive millions of requests per month. It emphasizes how Workers offloads maintenance costs and scaling concerns, allowing Nodecraft to focus on application development. The post also touches on the integration of Workers Sites with HTMLRewriter for dynamic content injection into static pages and expresses anticipation for future integrations with Cloudflare Pages and R2.
Nov 2021Automatically generating types for Cloudflare WorkersThis post details the automation of type generation for Cloudflare Workers, specifically for Rust and TypeScript. An internship project developed a pipeline that runs during Workers runtime builds to generate accurate and up-to-date types. This pipeline creates TypeScript and Rust types, as well as an intermediate JSON representation, ensuring consistency and enabling other language ecosystems to generate their own types. Overrides are used for concepts like generics and function overloads not directly supported by the C++ runtime.
Nov 2021JavaScript modules are now supported on Cloudflare WorkersIntroduced support for JavaScript modules (ES modules) in Cloudflare Workers, enabling import/export syntax for code organization. Updated event handler syntax for module workers to accept explicit parameters for Request/Controller, environment variables (bindings), and context. Enabled importing WebAssembly, text, and binary modules.
Nov 2021Introducing Services: Build Composable, Distributed Applications on Cloudflare WorkersIntroduced 'Services' as a new composable building block for Cloudflare Workers applications, enabling inter-service communication and multiple deployment environments. Introduced 'service bindings' for zero-cost, direct HTTP communication between services, eliminating network latency and enabling code reuse. Services are automatically migrated from existing scripts, and versioning/auditing are included for environments.
Nov 2021Introducing Relational Database ConnectorsThis post introduces support for relational databases (Postgres, MySQL) from Cloudflare Workers. It details the challenges of serverless database connections (TCP requirements, library compatibility, connection management) and outlines Cloudflare's initial approach using cloudflared tunnels and a shim-layer to adapt socket APIs. The post also highlights future plans for native TCP support, connection pooling, and global data caching, inviting developer collaboration.
Nov 2021Developer Spotlight: Winning a Game Jam with Jamstack and Durable ObjectsThis post details the architecture and implementation of a game jam entry, 'Full Tilt,' which leverages Cloudflare Workers and Durable Objects for on-demand, geographically distributed game rooms. It explains the use of Durable Objects for creating stateful 'mini servers' or 'rooms' that clients can connect to via WebSockets. A 'Room Hub' Durable Object is introduced to manage the mapping between short, human-readable room codes and the randomly generated Durable Object IDs, ensuring that game rooms are created geographically close to the end-user. The post also discusses the trade-offs between WebRTC and a serverless approach for communication and the design of the room code generation to avoid confusion.
Nov 2021Making connections with TCP and Sockets for WorkersIntroduces the development of APIs and infrastructure to support TCP, UDP, and QUIC-based protocols in Cloudflare Workers, enabling non-HTTP socket connections. Demonstrates an example of connecting to a remote Postgres server via WebSocket over a Cloudflare Tunnel using a Deno-based Postgres client driver adapted for standard fetch and WebSockets APIs. Proposes a new, standardized JavaScript API for socket connections (client-side) and introduces the concept of 'Socket Workers' that can be connected to directly using raw TCP, UDP, or QUIC protocols.
Nov 2021Durable Objects — now Generally AvailableThis post announces the General Availability of Durable Objects, a key feature within the Cloudflare Workers platform. Durable Objects provide a new programming paradigm for state coordination across Workers, enabling developers to build complex, globally scalable applications like collaborative editors and game servers with simplified code. The post highlights improvements made since the early access announcement, including enhanced reliability, performance, jurisdictional restrictions, and caching, and outlines future development plans for replication and geo-distribution.
Nov 2021Workers adds support for two modern data platforms: MongoDB Atlas and PrismaThis post announces the integration of MongoDB Atlas and Prisma with Cloudflare Workers. It details Cloudflare's strategy for data on Workers, which includes first-party solutions (Workers KV, Durable Objects), support for NoSQL databases over HTTP and TCP Database Connectors, and partnerships with data companies. The post highlights the benefits of MongoDB Atlas (document model, transactions, Global Clusters) and Prisma (ORM, type-safety, schema migrations, supported databases like Postgres, MySQL, SQL Server, SQLite, and MongoDB) for Workers developers. It also mentions the availability of client SDKs from Realm for MongoDB and Prisma for Prisma, and the use of Prisma Data Proxy for integration.
Oct 2021Introducing Custom Headers for Cloudflare PagesThis post introduces native support for custom headers and enhanced redirects within Cloudflare Pages. It highlights how this feature, built on Cloudflare Workers, simplifies the configuration of SEO directives (like X-Robots-Tag), security headers (X-Frame-Options, Content-Security-Policy), and CORS policies directly within a Pages project via a `_headers` file. It also details improvements to the `_redirects` file with splats and placeholders. The post emphasizes the improved developer experience and the underlying engine's similarity to the URLPattern specification.
Oct 2021Cloudflare Tunnel for Content TeamsThis post details how Cloudflare Tunnel and Cloudflare Access can be used by technical writers to create secure, shareable preview environments for documentation changes. It outlines the steps for setting up a named tunnel, routing DNS to it, configuring it to serve local development servers, and securing it with an Access policy restricted to internal users. This enables a more efficient feedback loop for content development.
Oct 2021Backwards-compatibility in Cloudflare WorkersIntroduced the concept of 'compatibility dates' for Cloudflare Workers. This allows for the introduction of backwards-incompatible changes to the Workers Runtime by providing developers with a mechanism to opt-in to these changes. Developers can set a compatibility date in their project metadata, and the runtime will selectively apply new behaviors based on this date. This addresses the challenge of fixing bugs or improving existing functionality without breaking existing production applications.
Oct 2021Tunnel: Cloudflare’s Newest HomeownerIntroduced a new UI in the Cloudflare for Teams Dashboard for managing Cloudflare Tunnel. This UI provides enhanced visibility into tunnel status, routes, uptime, connectors, and cloudflared versions. It also includes an interactive onboarding guide for setting up tunnels and managing them at scale. The UI offers filtering and sorting capabilities for tunnels and displays cloudflared replica statuses. The post also mentions future plans for incorporating more analytics and improving the onboarding experience.
Oct 2021Dynamic Process Isolation: Research by Cloudflare and TU GrazIntroduced Dynamic Process Isolation, a novel Spectre defense mechanism for Cloudflare Workers. This defense uses hardware performance counters to detect branch mispredictions indicative of Spectre variant 1 attacks. Upon detection, suspicious Workers are moved into separate OS processes, leveraging kernel-level defenses. The research, conducted in partnership with TU Graz, also developed a working Spectre variant 1 attack that could leak memory at 120 bits per hour in an ideal scenario, demonstrating the need for enhanced defenses.
Sep 2021Real-Time Communications at ScaleIntroduces WebRTC Components, a new suite of products designed to help build the next generation of real-time, interactive applications by leveraging Cloudflare's global edge network to improve connectivity for WebRTC-based video and audio applications. This includes scaling to tens of thousands of participants, leveraging DDoS mitigation, and enforcing IP and ASN-based access policies. The platform aims to abstract the need to manage and configure low-level infrastructure, authentication, authorization, and participant permissions, offering developer-first APIs for participants, rooms, and channels. It also integrates with Cloudflare for Teams for organizational access policies, and with Stream Live and Stream Connect for broadcasting and recording.
Sep 2021Announcing Cloudflare R2 Storage: Rapid and Reliable Object Storage, minus the egress feesThis post announces Cloudflare R2 Storage, a new object storage service that integrates deeply with Cloudflare Workers. R2 offers S3 API compatibility with zero egress fees, significantly lower storage costs, and intelligent dynamic tiering. Its key contribution to the feature thread is enabling developers to build data pipelines and manipulate objects stored in R2 directly from the edge using Workers, opening up new possibilities for data processing, IoT data ingestion, and content delivery at the edge.
Sep 2021Bringing OAuth 2.0 to WranglerThis post introduces the integration of the OAuth 2.0 protocol into Wrangler, the Workers command-line interface. This enhances the developer experience by replacing cumbersome API token management with a more secure and user-friendly authorization flow. It details the implementation of the Authorization Code Flow with PKCE challenges, enabling users to select specific permissions (scopes) and revoke access easily via `wrangler logout`. The post also highlights the security improvements brought by CSRF states, PKCE challenges, and short-lived access tokens.
Sep 2021Cloudflare Pages is Lightning FastThis post details the performance advantages of Cloudflare Pages, highlighting its foundation on Cloudflare's global edge network, adoption of new web standards (TLS 1.3, IPv6, QUIC/HTTP/3), and a developer-centric experience with fast builds and integrated Web Analytics. It benchmarks Pages against competitors, demonstrating superior Time to First Byte (TTFB) globally. The post also emphasizes the importance of Web Core Vitals and how Pages facilitates achieving them.
Sep 2021Profiling Your Workers with WranglerIntroduced beta support for local CPU profiling of Cloudflare Workers using Wrangler and the Chrome DevTools protocol. This enables developers to connect to a locally running Worker via `wrangler dev --inspect` and use `chrome://inspect` to profile CPU usage, analyze flame graphs, and identify performance bottlenecks in their edge code.
Sep 2021Announcing Project Turpentine: an easy way to get off VarnishIntroduced Turpentine, a VCL-to-TypeScript converter that parses VCL, generates optimized and commented TypeScript code, and deploys it to Cloudflare Workers. This enables migration from Varnish configurations to a modern, programmable edge platform, leveraging Cloudflare's full suite of features.
Sep 2021Cloudflare Workers: the Fast Serverless PlatformThis post details performance improvements in Cloudflare Workers, highlighting a 30% increase in P90 performance over three years and a 210% advantage over Lambda@Edge. It explains that Workers' speed is due to its edge-first architecture using lightweight V8 isolates, which eliminates cold starts, and its ability to benefit from V8 compiler updates and Cloudflare's network infrastructure. The post also emphasizes the rapid global deployment of Workers (under a second) and ongoing efforts to improve the developer experience through faster deployment cycles and debugging tools.
Sep 2021Native Rust support on Cloudflare WorkersIntroduced the `worker` crate for native Rust support on Cloudflare Workers, enabling idiomatic Rust development via WebAssembly. This eliminates the need for JavaScript trampolines and provides Rust-friendly APIs for Workers features like KV stores and Durable Objects. The post includes a code snippet demonstrating Rust Worker implementation and instructions for using `wrangler` to generate Rust projects.
Aug 2021Introducing logs from the dashboard for Cloudflare WorkersThis post introduces integrated logging and exception tracking for Cloudflare Workers, accessible directly from the dashboard and via the `wrangler tail` command. This feature simplifies debugging by allowing developers to view `console.log` output and exceptions without any configuration or additional cost. It also enhances visibility into Durable Objects interactions and provides advanced filtering capabilities through the `wrangler` CLI, including sampling and structured log output.
Aug 2021Building a Pet Cam using a Raspberry Pi, Cloudflare Tunnels and TeamsThis post details how Cloudflare Tunnel and Cloudflare for Teams can be used to securely expose an internal service (a Raspberry Pi pet cam) to the internet. It demonstrates the setup process, including installing and configuring Cloudflare Tunnel on a Raspberry Pi, and integrating Cloudflare Access with Google authentication for secure remote access. This extends the use case of edge computing to personal IoT devices and highlights the security benefits of Cloudflare's platform for such applications.
Aug 2021Building the Cloudflare Summer Challenge ApplicationThis post details the technical implementation of the Cloudflare Summer Developer Challenge application, which uses Cloudflare Workers Sites (a precursor to Cloudflare Pages) for static site hosting and backend API functionality. It highlights the use of the `worktop` web framework for routing, a custom build system for inlining CSS and JavaScript into HTML for performance, and the `esbuild` bundler for the Worker. The post also discusses dynamic variable injection into HTML templates during runtime.
Aug 2021Modernizing a familiar approach to REST APIs, with PostgreSQL and Cloudflare WorkersThis post introduces the capability to build REST APIs that communicate directly with PostgreSQL databases from Cloudflare Workers. It highlights the use of PostgREST to generate a REST API from Postgres, Cloudflare Tunnel for secure exposure, and the `postgrest-js` library for interacting with the API within Workers. It also explores how Workers can be used for intelligent caching and new scaling approaches for Postgres applications.
Aug 2021Durable Objects: Easy, Fast, Correct — Choose threeThis post introduces Durable Objects as a significant enhancement to Cloudflare Workers. It explains how Durable Objects provide a single-threaded execution model with private, persistent storage, which simplifies state management and eliminates common race conditions and performance issues previously encountered when interacting with distributed storage. The post highlights that these improvements are achieved by fixing the runtime model, making applications correct by default without requiring code changes, and significantly improving performance by reducing I/O round trips and enabling in-memory caching.
Jul 2021Introducing Workers Usage NotificationsIntroduced Workers usage notifications, including a weekly summary of usage statistics (request counts, duration, egress data transfer, median CPU time) and an on-demand 'Workers Usage Report' triggered by a 25% increase in CPU usage compared to the previous seven days. These notifications aim to proactively inform developers about their Worker's production traffic and potential issues like bugs or unexpected cost increases.
Jun 2021Announcing Rollbacks and API Access for PagesThis post introduces two key features for Cloudflare Pages: deployment rollbacks and API access. Rollbacks allow users to revert to previous working deployments with a single click, enhancing production stability. The Pages API provides programmatic control over projects and deployments, enabling custom integrations and automations. The post also highlights how Cloudflare Workers can be used to interact with the Pages API, for example, to trigger hourly builds for dynamic static content.
Jun 2021Building Waiting Room on Workers and Durable ObjectsThis post details the technical design and implementation of Cloudflare's Waiting Room product, which was built using Cloudflare Workers and Durable Objects. It explains the core functionality of managing traffic spikes by creating an orderly queue, the configuration options (Total Active Users, New Users Per Minute, Session Duration), and the underlying mechanisms. Key technical aspects include: issuing encrypted cookies as tickets, coordinating user slot allocation across data centers using historical traffic data, clustering users by bucketId for queue management, and maintaining the waiting room state through aggregated historical data from different data centers. The post also illustrates the user experience with cookie content and a traffic chart.
May 2021QUIC Version 1 is live on CloudflareThis post announces the general availability of QUIC Version 1 (RFC 9000) and HTTP/3 on Cloudflare's network. It details the technical implementation, including how Cloudflare servers listen for QUIC traffic on UDP port 443, the handshake process involving version identifiers and ALPN, and the use of HTTP Alternative Services (RFC 7838) for protocol negotiation. It highlights the use of Cloudflare's open-source quiche library in Rust for powering this functionality and mentions the quiche-client tool for debugging and interoperability testing.
May 2021Building real-time games using Workers, Durable Objects, and UnityThis post details the technical implementation of a real-time multiplayer game, 'Durable World,' built entirely on Cloudflare's stack. It showcases how Cloudflare Workers, Durable Objects, and WebSockets can be combined to manage game state, synchronize player positions, and handle real-time communication. The post provides code examples for the Durable Object's `Character` module, demonstrating WebSocket setup, session handling, and broadcasting game state updates. It also touches upon the client-side implementation in Unity, highlighting the authoritative client model and how game objects are managed.
May 2021Multiplayer Doom on Cloudflare WorkersThis post details the technical challenges and solutions involved in porting multiplayer Doom to run on Cloudflare Workers and Durable Objects. It covers compiling Chocolate Doom to WebAssembly using Emscripten, adapting the game's main loop for an event-driven browser environment, and implementing a new network module (`net_websockets.c`) to tunnel UDP-based game traffic over WebSockets. Key technical contributions include creating a fake IP address for routing, implementing a packet queue to buffer TCP-based WebSocket traffic, and demonstrating the feasibility of low-latency, real-time multiplayer gaming on the edge.
May 2021Automating Cloudflare Tunnel with TerraformThis post introduces the automation of Cloudflare Tunnel creation and management using Terraform. It details how Named Tunnels and their associated API endpoints, combined with Terraform's `cloudflare_argo_tunnel` resource and `templatefile` function, allow for the dynamic provisioning of tunnels and their configuration on origin servers. The example demonstrates setting up a tunnel to proxy traffic to a Google Compute Engine instance running HTTPbin and SSH, with Zero Trust policies applied to SSH access.
May 2021Highly available and highly scalable Cloudflare tunnelsIntroduced the ability to run multiple instances of `cloudflared` for a single tunnel, enabling elastic auto-scaling, graceful restarts, easier Kubernetes integration, and more reliable tunnels. This allows for zero-downtime configuration changes and simplifies Kubernetes deployments by enabling multiple `cloudflared` pods to manage the same tunnel.
Apr 2021SSHing to my Raspberry Pi 400 from a browser, with Cloudflare Tunnel and Auditable TerminalThis post details the setup of Cloudflare Tunnel and Auditable Terminal to provide browser-based SSH access to a Raspberry Pi 400. It covers preparing the Pi (updates, enabling SSH), installing and authenticating the `cloudflared` daemon, configuring a tunnel, and setting up Cloudflare for Teams to manage access policies. The author highlights the ease of use and security benefits of this integrated solution for remote access.
Apr 2021Containers at the edge: it’s not what you think, or maybe it isThis post introduces the capability to run containers at the edge, complementing the existing isolate-based model for edge compute. It details the rationale for using containers for legacy systems and specific applications like browser isolation, contrasting it with the benefits of isolates for distributed systems. The post also discusses the challenges of migrating containerized workloads to the edge and the potential for cold starts and state management complexities.
Apr 2021Announcing Cloudflare’s Database PartnersThis post announces partnerships with Macrometa and Fauna, expanding the capabilities of Cloudflare Workers by enabling seamless integration with edge-first databases. It highlights how these partnerships address the challenge of managing 'state' at the edge, complementing Workers KV and Durable Objects by offering solutions for complex data querying, transactional workloads, and real-time data processing. The post details the specific offerings of Macrometa (global replication, NoSQL, search, pub/sub, streams) and Fauna (global transactional database, GraphQL, custom business logic), and provides case studies demonstrating their use with Workers for e-commerce and AI voice assistants.
Apr 2021Introducing workers.new, custom builds, and improved logging for WorkersIntroduced `workers.new` for instant JavaScript editor access and prototyping. Enabled custom build scripts for `wrangler` to support arbitrary JavaScript bundlers (webpack, Rollup, Parcel, esbuild, etc.) by allowing users to provide their own build script and upload directory. Enhanced `wrangler tail` with a new 'pretty' output format for improved log readability, alongside the existing JSON format.
Apr 2021Node.js support in Cloudflare WorkersIntroduced support for Node.js packages within Cloudflare Workers, enabling the use of over 20,000 packages that rely on webpack or other polyfill bundlers. This allows developers to import and use popular libraries like node-jose, itty-router, and graphql. The post also outlines future plans to increase worker size limits and support native Node.js APIs by reimplementing modules directly into the Workers runtime, starting with Stripe.js SDK, Twilio Client JS SDK, and the net module.
Apr 2021Announcing Cloudflare for SaaS for EveryoneThis post announces the rebranding of 'SSL for SaaS' to 'Cloudflare for SaaS' and its availability to all customers, not just Enterprise. It highlights how Cloudflare for SaaS, when combined with Cloudflare Workers, provides a comprehensive solution for SaaS providers by abstracting away infrastructure management, security, and performance concerns, allowing developers to focus on their core product. It showcases Statusflare as an example of a SaaS product built on Workers that benefits from Cloudflare for SaaS for custom domain and certificate management.
Apr 2021Introducing WebSockets Support in Cloudflare WorkersIntroduced support for WebSockets in Cloudflare Workers, enabling bidirectional communication between clients and Workers. This involves handling the 'Upgrade' header, instantiating WebSocketPair, and using the `webSocket` property on the Response object with a 101 status code. The `handleSession` function demonstrates accepting the WebSocket, listening for 'message' and 'close' events. Client-side connection uses the standard browser WebSocket API. The post highlights the synergy between WebSockets and Durable Objects for building stateful, real-time applications at the edge. It also discusses pricing implications for WebSockets on Workers Unbound and Bundled plans, and proposed pricing for Durable Objects with WebSockets.
Apr 2021Improve your page experience with AMP and Cloudflare Workers UnboundThis post introduces the integration of AMP Optimizer with Cloudflare Workers, enabling server-side optimization of AMP pages. It details the request flow, including caching and origin fetching, and highlights the use of Workers Unbound for handling longer optimization tasks. The integration also adds automatic preloading of resources and generates responsive images using Cloudflare Image Optimizer. The post provides performance gains data and links to the GitHub repository for the cloudflare-amp-optimizer.
Apr 2021Announcing Cloudflare Workers Unbound for General AvailabilityThis post announces the general availability of Cloudflare Workers Unbound, extending the CPU execution limit for HTTP requests to 30 seconds for paid plans. It also details a private beta for Cron Triggers with up to 15 minutes of execution time. Pricing changes include a reduction in egress costs by half and an increase in included usage for the $5/month plan. The post highlights use cases like genomic analysis, enterprise caching, and sandboxing, and provides instructions for enabling Workers Unbound via the dashboard and wrangler CLI.
Apr 2021Bringing AI to the edge with NVIDIA GPUsThis post announces the integration of NVIDIA GPUs and TensorFlow into the Cloudflare Workers platform, enabling AI inference at the edge. It highlights the ability to run AI-based applications globally with low latency, securely handle models, and use familiar tools. The post also showcases a demo application, 'nataornot.com', which uses a TensorFlow model running on an NVIDIA A100 GPU at the edge.
Apr 2021Location-based personalization at the edge with Cloudflare WorkersIntroduced free and universally accessible geolocation data (country, city, continent, lat/lon, postal code, region, timezone) within Cloudflare Workers. This enables server-side personalization based on user location, eliminating the need for client-side JavaScript or cookies for such features. Provided examples for 'Hello World', personalized UI design based on local time, and location-based applications like air quality reporting.
Apr 2021Cloudflare Pages is now Generally AvailableThis post announces the general availability of Cloudflare Pages, a platform for building, hosting, and collaborating on Jamstack sites. It highlights key features like seamless builds, instant feedback for teams, bullet-proof security and scale, integrated web analytics, built-in redirects via a `_redirects` file, protected previews with Cloudflare Access integration, live previews with Cloudflare Tunnel, and optimized assets through image compression (Polish) and Gzip/Brotli. It also outlines future plans including GitLab/Bitbucket support, webhooks, A/B testing, and the long-term vision of enabling full-stack application development with Cloudflare Workers and Durable Objects.
Mar 2021Durable Objects, now in Open BetaThis post announces the open beta of Durable Objects, a significant advancement for Cloudflare Workers. It introduces Durable Objects as a new paradigm for stateful serverless, providing coordination across multiple Workers and strongly consistent edge storage. The post details the core concepts, use cases (complex API features, real-time games), pricing comparisons with major cloud providers (AWS Lambda and DynamoDB), and highlights key benefits like built-in high availability and strong consistency at no extra cost. It also mentions recent feature additions like jurisdictional restrictions and Wrangler support.
Dec 2020Using One Cron Parser Everywhere With Rust and SaffronThis post details the development and integration of 'saffron', a Rust-based cron parser, to solve the problem of inconsistent cron expression parsing across different parts of the Cloudflare Workers stack (UI, API, backend). It highlights the challenges of non-standardized cron extensions, the use of the 'nom' crate for parsing, and the benefits of using a single, shared parser for consistency and improved developer experience. The post also discusses the evolution of the cron parser from multiple disparate libraries to a unified solution, including addressing off-by-one errors in day-of-week interpretation.
Dec 2020Cloudflare Acquires LincThis post announces the acquisition of Linc, a company specializing in frontend application bundles (FABs), to accelerate the development of full-stack applications on Cloudflare Pages. FABs are presented as a deployment artifact that can handle static sites, dynamic backends, and server-side rendering. The integration with Cloudflare Workers is highlighted as a key enabler for edge-based full-stack applications, allowing for assets and server logic to be handled by Workers, potentially using Workers KV for asset storage, leading to improved performance compared to traditional CDNs and serverless platforms.
Dec 2020Introducing Cloudflare Pages: the best way to build JAMstack websitesThis post introduces Cloudflare Pages, a new service designed to simplify the building and hosting of JAMstack websites. It highlights seamless Git integration for automated builds and deployments, unique preview URLs for code reviews and stakeholder feedback, infinite staging environments for feature branches, and collaboration features. Crucially, it announces the future integration of Pages with Cloudflare Workers, envisioning a unified platform for building dynamic applications on the edge, extending the JAMstack paradigm beyond static sites.
Dec 2020Supporting Jurisdictional Restrictions for Durable ObjectsThis post introduces Jurisdictional Restrictions for Durable Objects, a new feature for Cloudflare Workers that allows developers to specify geographical regions for data storage and processing. This enhances compliance with data localization regulations and simplifies the development of stateful, serverless applications by abstracting away infrastructure management for regional data control.
Nov 2020Building Black Friday e-commerce experiences with JAMstack and Cloudflare WorkersThis post details the implementation of an open-source e-commerce application built entirely on Cloudflare Workers. It showcases Workers Sites for static asset hosting, Nuxt.js for the frontend, and Sanity.io for headless CMS data management. The post highlights the integration with Stripe for payment processing, including generating checkout sessions via REST requests and handling webhooks for purchase completion. It also demonstrates the use of Workers KV for distributing unique download links and Mailgun for sending transactional emails. The core contribution is the demonstration of Workers as a unified platform for static hosting, API serving, and webhook consumption within a single codebase, enabling scalable e-commerce experiences.
Nov 2020Workers KV - free to try, with increased limits!Introduced a free tier for Workers KV with 100,000 read operations, 1,000 write/list/delete operations per day, and 1 GB of storage. Increased the maximum value size for Workers KV from 10 MB to 25 MB. Provided code examples for binding KV namespaces, uploading keys, and serving files from Workers. Highlighted use cases like mass redirects, access control, translation keys, and configuration data. Noted that for use cases requiring the most up-to-date data, Durable Objects is a better solution.
Oct 2020Road to gRPCThis post details the technical implementation of gRPC support on Cloudflare's edge network. It explains the challenges of gRPC's reliance on HTTP/2 trailers and its bidirectional streaming capabilities, which were not fully supported by Cloudflare's existing infrastructure. The solution involved converting gRPC to HTTP/1.1 gRPC-web internally, leveraging existing WAF and other security services, and then converting back to HTTP/2 gRPC for origin communication. The post also highlights the development of an in-house origin proxy to support HTTP/2 connections to origins and the implementation of gRPC streaming support. Interoperability testing with Envoy and existing gRPC implementations was crucial for ensuring reliability.
Oct 2020Argo Tunnels that live foreverThis post introduces a new architecture for Argo Tunnel that separates persistent objects (DNS records, cloudflared daemon) from ephemeral objects (connections). It introduces the concept of 'Named Tunnels' which have a permanent name and UUID, allowing DNS records to point to this stable identifier. This prevents the need to recreate DNS records when `cloudflared` restarts, improving stability and simplifying management. It also allows Named Tunnels to be treated as origin servers in Cloudflare's control plane. The post details the steps for using this new architecture: logging in with `cloudflared tunnel login`, creating a Tunnel with `cloudflared tunnel create <name>`, configuring Tunnel details, running the Tunnel with `cloudflared tunnel run <name>`, and sending traffic to the Tunnel by pointing DNS records to the UUID subdomain or adding it to load balancer pools.
Oct 2020Exploring WebAssembly AI Services on Cloudflare WorkersThis post details an exploration of deploying AI models at the edge using WebAssembly (WASM) within Cloudflare Workers. It showcases how Latent AI's tools compress AI models (e.g., MobileNetV2) to reduce memory footprint and compile them into WASM programs. The analysis includes performance metrics for different bit-precisions (32-bit float, 16-bit int, 8-bit int) and model sizes, highlighting the benefits of 8-bit precision for reduced memory operations and faster inference times. The authors suggest using minimal compute/memory footprints, 8-bit precision, and smart caching for AI models on the edge.
Oct 2020Let's build a Cloudflare Worker with WebAssembly and HaskellThis post details the process of compiling Haskell code to WebAssembly using Asterius and deploying it as a Cloudflare Worker. It covers setting up the Asterius environment, writing a Haskell module with a foreign export for JavaScript, creating a JavaScript loader, compiling the code using `ahc-link`, and deploying the resulting WebAssembly module and JavaScript script to Cloudflare Workers via the API. It also demonstrates a more complex scenario using `ahc-cabal` to build a Cabal project and `ahc-dist` to compile it to WebAssembly for Workers.
Sep 2020Introducing Cron Triggers for Cloudflare WorkersIntroduced Cron Triggers for Cloudflare Workers, enabling scheduled execution of Worker scripts at fixed intervals or specific times, independent of HTTP requests. This feature leverages underutilized global infrastructure for cost-effective execution and is available at no additional cost, counting towards existing request caps. The implementation involves API-based schedule creation, database records, and a distributed service for schedule evaluation and distribution to edge nodes.
Sep 2020Making Time for Cron Triggers: A Look InsideIntroduced Cron Triggers for Cloudflare Workers, enabling scheduled execution of Workers. This involved creating a new 'scheduled' event type, new APIs for managing schedules, and a distributed system for scheduling and executing these triggers from the edge. The implementation uses Rust for the schedule runner service deployed via Nomad, with a custom cron parser and Cap'n Proto RPC for communication with the runtime.
Sep 2020Workers Durable Objects Beta: A New Approach to Stateful ServerlessThis post introduces Durable Objects, a new capability for Cloudflare Workers that enables stateful serverless applications with strong consistency and real-time coordination. It addresses the previous limitation of managing state and coordinating clients entirely on the edge, allowing for the development of full applications without centralized origin servers. Key features include persistent, private, and co-located storage for each object, and the ability to coordinate between clients through a single object instance. The post also announces the beta launch of Durable Objects and the integration of WebSocket support into Workers.
Sep 2020Rendering React on the Edge with Flareact and Cloudflare WorkersIntroduced Flareact, a new open-source React framework specifically designed for Cloudflare Workers. Flareact enables rendering React applications at the edge, offering a hybrid approach similar to Next.js's SSG and Incremental Static Regeneration. It leverages Cloudflare Workers' runtime and edge caching capabilities to provide dynamic content with low latency and high scalability. Key features include file-based page routing, dynamic page paths, edge-side data fetching (getEdgeProps), API Routes, and client-side routing. The framework addresses the challenge of running Node.js-centric frameworks on V8 isolates by using Webpack's require.context for page discovery and a custom client-side router.
Aug 2020Asynchronous HTMLRewriter for Cloudflare WorkersIntroduced asynchronous handlers to HTMLRewriter, enabling developers to perform awaitable operations within element handlers. This allows for dynamic HTML modification based on fetched data, user context, or external API calls. Enhanced CSS selector support to include `nth-child` selectors. Provided examples for user customization and image restoration using external APIs.
Aug 2020Announcing wrangler dev — the Edge on localhostIntroduced `wrangler dev` as a GA feature, providing an edge-based development environment for Cloudflare Workers. This enables live reloading of code pushed to the edge, direct terminal access to `console.log` output, and the ability to test edge-specific features like Cache API and KV namespaces in a development-specific environment without affecting production data. This enhances the developer experience by offering a high-fidelity, consistent testing environment that mirrors production without the complexity of local environment replication.
Aug 2020Improving the Wrangler Startup ExperienceThis post introduces `wrangler login`, a new authentication flow for the Wrangler CLI that simplifies the developer experience for managing Cloudflare Workers. It replaces the manual API token creation process with a seamless, browser-based authentication flow that leverages existing Cloudflare user credentials and employs asymmetric RSA encryption for security.
Aug 2020Introducing Deploy ButtonsIntroduced 'Deploy Buttons' which allow users to deploy projects to Cloudflare Workers directly from GitHub repositories without requiring a local development environment. This feature streamlines the onboarding process for new developers by enabling a one-click deployment flow through a web-based tool. The implementation involves connecting GitHub and Cloudflare accounts, forking the repository, and deploying via a GitHub Action using the `wrangler-action`. Instructions are provided for creating custom deploy buttons by adding a GitHub Actions workflow and specific Markdown to project READMEs.
Aug 2020New and improved Workers DocsThis post details significant improvements to the Cloudflare Workers documentation, including content reorganization inspired by Divio's documentation system, improved formatting for reference pages and command breakdowns, redesigned example and tutorial pages with new UI components and sorting/filtering capabilities, an upgraded Algolia search experience, and the addition of dark mode. The underlying documentation engine was also upgraded and is open-sourced.
Jul 2020Making magic: Reimagining Developer Experience for the World of ServerlessIntroduced `wrangler dev`, an edge-based development environment for Cloudflare Workers that provides a fast feedback loop by tunneling local development to the edge. This aims to improve developer experience by offering the speed of client-side execution with the accuracy and control of edge execution, addressing the limitations of traditional local development environments. The post also emphasizes the ease of getting started with Workers, highlighting low Time To First Byte (TTFB) and Time To First Dopamine (TTFD) for new users, and the availability of templates and tutorials.
Jul 2020Eliminating cold starts with Cloudflare WorkersIntroduced an optimization to eliminate cold starts for Cloudflare Workers by leveraging TLS handshake SNI information. During the TLS ClientHello, the Workers runtime is now hinted to eagerly load the Worker associated with the hostname. This pre-warming ensures that by the time the handshake is complete, the Worker is already warm and ready to execute code immediately upon request arrival, effectively achieving zero cold start latency. This optimization is available for all Workers customers and is deployed to production for root hostnames.
Jul 2020Mitigating Spectre and Other Security Threats: The Cloudflare Workers Security ModelThis post details the security architecture of Cloudflare Workers, focusing on isolation mechanisms and API design. It explains the use of V8 isolates for multi-tenancy, process-level isolation for specific features (like devtools debugger) and as a defense against Spectre, and whole-process sandboxing using Linux namespaces and seccomp. It also covers the role of the supervisor process and capability-based security for API mediation, and the network access restrictions via inbound and outbound proxy services. The post also addresses the 'patch gap' for V8 bugs and Cloudflare's strategy for rapid deployment of fixes.
Jul 2020Cloudflare Workers Announces Broad Language SupportThis post introduces support for Python, Scala, Kotlin, Reason, and Dart on Cloudflare Workers. It details the underlying mechanisms for adding support for dynamically typed languages (Python via Transcrypt) and statically typed languages (Scala via Scala.js), including the use of Wrangler, webpack loaders, and type definitions for JavaScript APIs. The post also provides examples of how to get started with these new languages and discusses the trade-offs of compiling to JavaScript versus WebAssembly.
Jul 2020The Migration of Legacy Applications to WorkersThis post details the migration of a legacy Node.js application to Cloudflare Workers. It demonstrates how to: 1. Keep existing business logic intact by directly porting JavaScript assets. 2. Build a new preprocessing layer in Workers to replace the Node.js HTTP module. 3. Use Cloudflare Access for zero-trust authentication and Argo Tunnels for secure origin connections, providing a 'quick win' security upgrade before migrating the compute. 4. Utilize Wrangler tooling to bundle the new preprocessing layer with the existing business logic into a Workers application. The post highlights the benefits of serverless platforms like Workers, including instant scaling, simplified credential management, and reduced operational costs.
Jul 2020Introducing Workers UnboundIntroduced Workers Unbound, a private beta offering that removes restrictive CPU limits for Cloudflare Workers, enabling longer execution times for intensive applications like image processing and complex algorithms. This is achieved by leveraging V8 Isolates, which are more lightweight than containers and allow for efficient multi-tenant code execution at the edge. The platform aims to be faster, more affordable, and more flexible than traditional centralized serverless platforms.
Jul 2020The Edge Computing Opportunity: It’s Not What You ThinkThis post argues that while speed is a benefit of edge computing, consistency (zero nanosecond cold starts), cost-effectiveness (due to efficient architecture), ease of use, and compliance are more important drivers for adoption. It highlights Cloudflare Workers' ability to achieve near-zero cold starts, positioning it as a leader in consistency. The post also touches on the cost advantages of edge computing due to Cloudflare's network architecture and peering.
Jul 2020Serverless Rendering with Cloudflare WorkersThis post details how to implement server-side rendering at the network edge using Cloudflare Workers, Workers Sites, Wrangler, and HTMLRewriter. It demonstrates building a dynamic web application ('Peer With Cloudflare') that fetches data from the PeeringDB API and embeds it into static HTML served from the edge. The post covers generating a Workers Site, using URL parameters for state management, modeling data from third-party APIs, and leveraging HTMLRewriter for dynamic content modification. It highlights the benefits of edge-rendered content for caching, SEO, and link previews, while mitigating the latency concerns of traditional server-side rendering.
Jun 2020Catching up with Workers KVIntroduced metadata support for Workers KV, allowing arbitrary JSON to be stored with key-value pairs and retrieved using `getWithMetadata`. This enables richer data association, such as content types and ETags. Also, implemented a second source of truth for Workers KV writes in Europe, significantly reducing write latency for users in that region.
Jun 2020Lessons from a 2020 intern assignmentThis post details a take-home exercise designed for Cloudflare's 2020 internship applicants, focusing on building an A/B testing application using Cloudflare Workers. It explains the exercise's requirements, provides a sample solution, and discusses common mistakes and implementations observed from submissions. It also introduces extra credit challenges involving content replacement using string manipulation and the HTMLRewriter API, and persisting user choices via cookies. The post highlights the utility of Workers for self-contained, full-stack exercises and the feedback gained on the Workers ecosystem (documentation, wrangler CLI) from the application process.
Apr 2020Helping with COVID-19 Projects: Cloudflare Workers now free through Project GalileoThis post details the offering of free Cloudflare Workers access through Project Galileo for COVID-19 related projects. It showcases four example projects (API-COVID19-In, MakeFaceMasks, Mask A Hero NY, CovidTracking API) that leverage Workers for rapid deployment, scalability, and handling high traffic. Specific technical benefits highlighted include ease of setup, cost-effectiveness compared to maintaining origins, automatic scaling, cache breaking, and the ability to handle significant traffic spikes without downtime. The CovidTracking API example specifically mentions using Workers as a serverless proxy, caching fetched data, and utilizing Cloudflare KV storage for parsed and serialized results with TTL limits.
Apr 2020Cloudflare Workers Now Support COBOLThis post details the technical process of enabling COBOL to run on Cloudflare Workers by compiling it to WebAssembly. It covers the use of GnuCOBOL to compile COBOL to C, Emscripten to compile C to WebAssembly, and the optimization of the resulting binary by using a JavaScript-based GMP library and removing unnecessary file system emulation. It also explains how JavaScript functions are used to generate HTTP responses, making the COBOL code accessible via HTTP. The post provides a toolchain and deployment instructions for users to run their own COBOL Workers.
Apr 2020Trailblazing a Development Environment for WorkersThis post details the development of `wrangler dev`, a local development server for Cloudflare Workers. It describes the architecture of `wrangler dev`, which involves building the Worker, uploading it to Cloudflare's preview API, and then proxying local HTTP requests to the preview session. It also covers the integration with the Chrome Devtools Protocol to enable `console.log` streaming and debugging capabilities within the local development environment.
Apr 2020Announcing the Beta for WARP for macOS and WindowsThis post announces the beta release of WARP clients for macOS and Windows, extending the Wireguard-based secure and fast internet connection technology beyond mobile devices. It also mentions plans to add WARP+ support leveraging Cloudflare's Argo network and future Linux client development.
Mar 2020Deploying security.txt: how Cloudflare’s security team builds on WorkersThis post details the implementation of security.txt using Cloudflare Workers. It highlights the use of the Wrangler CLI for automated deployment and version control, dynamic generation of the 'Expires' field using a Node.js script, and clear-signing of the security.txt file with a PGP key at build time. The Worker also serves the PGP public key alongside the security.txt file using multi-route support.
Mar 2020How Replicated Developers Develop RemotelyThis post details how Replicated, an infrastructure software company, leveraged Cloudflare Access and Argo Tunnel to create a secure, cloud-based development environment for their engineers. This solution moved development environments from local machines to cloud instances, reducing troubleshooting time and enabling seamless remote access via VS Code's Remote SSH extension. This represents an innovative application of Cloudflare's edge capabilities for developer productivity and security.
Mar 2020Addressing the Web’s Client-Side Security ChallengeThis post highlights how Cloudflare Workers can be leveraged to significantly improve client-side website security. It introduces Tala, a third-party security solution that integrates with Workers to automatically deploy browser-native security controls like Content Security Policy (CSP), Subresource Integrity (SRI), and HTTP Strict Transport Security (HSTS) at the edge. This integration addresses the growing problem of client-side vulnerabilities and offers a highly effective, performant, and easily deployable security solution.
Feb 2020Introducing Secrets and Environment Variables to Cloudflare WorkersIntroduced Secrets and Environment Variables to Cloudflare Workers, accessible via the Wrangler CLI and Workers Dashboard. Secrets are encrypted upon saving, while Environment Variables are stored in plain text. This addresses use cases for sensitive API keys and general configuration variables, improving deployment safety and developer experience by allowing secrets to be managed without direct code exposure or redeployment.
Jan 2020Announcing Built with WorkersThis post announces the launch of 'Built with Workers,' a new site designed to showcase projects built using Cloudflare Workers. It highlights the platform's capabilities for building high-performance applications with automatic scaling at the edge. The site features projects using Workers KV and Workers Sites, and many are open-source, providing direct links to GitHub repositories for learning and inspiration. The author draws parallels to early programming experiences with graphing calculators and the early internet, emphasizing the importance of examples and community sharing for technological adoption.
Jan 2020JAMstack at the Edge: How we built Built with Workers… on WorkersThis post details the architecture and implementation of the 'Built with Workers' website, which showcases projects built on Cloudflare Workers. It highlights the use of JAMstack principles (JavaScript, APIs, Markup) with Cloudflare Workers and Workers Sites for deploying static assets directly to the edge. The site uses Gatsby.js for framework, Sanity.io as a headless CMS, and Workers KV for storage. The post emphasizes the philosophical similarities between JAMstack and Workers, and the open-sourcing of the codebase.
Jan 2020Prototyping optimizations with Cloudflare Workers and WebPageTestThis post introduces a method for rapid prototyping of web performance optimizations by combining Cloudflare Workers with WebPageTest. It details how Cloudflare Workers can intercept and modify requests/responses, and how WebPageTest's `overrideHost` script command can redirect traffic through a Worker. It also provides examples of using Workers for basic request proxying, HTML rewriting with HTMLRewriter, request mangling (adding delays), and custom HTTP/2 prioritization schemes.
Nov 2019Rust streaming HTML parser/rewriterThis post details the development of LOL HTML, a Rust-based streaming HTML rewriter/parser with a CSS-selector based API, which serves as the backend for Cloudflare Workers' HTMLRewriter. It introduces a dual-parser architecture (lexer and tag scanner) to optimize performance by skipping non-matching content and avoiding expensive token propagation to the Workers runtime. It also describes a Rust macro-based DSL for defining Nondeterministic finite automata for parsing and byte slice processing optimizations using token outlines for lazy transformation into byte slices.
Nov 2019Introducing the HTMLRewriter API to Cloudflare WorkersIntroduced the GA release of the HTMLRewriter API for Cloudflare Workers. This API provides a streaming parser for manipulating HTML content directly at the edge, enabling dynamic applications and edge-side JAMstack architectures. It offers a jQuery-like experience for DOM manipulation using selectors and handlers, allowing for URL rewrites, content customization, and reducing origin load and client-side bloat. The post details an example of rewriting URLs and discusses the benefits of edge-side DOM modifications over client-side updates.
Nov 2019What’s new with Workers KV?This post announces significant updates to Workers KV, Cloudflare's global key-value store for Workers. New features include bulk upload/delete APIs, support for base64 encoded binary values, key listing with pagination and cursor support, prefix filtering for key listing, increased limits for namespaces (to 100) and value sizes (to 10MB), a visual KV browser in the Cloudflare dashboard for managing keys, and enhanced integration with the Wrangler CLI for creating, putting, and getting KV keys.
Sep 2019Not so static... Introducing the HTMLRewriter API Beta to Cloudflare WorkersIntroduced the HTMLRewriter API beta for Cloudflare Workers, enabling streaming HTML parsing and DOM manipulation with a jQuery-like JavaScript API. This allows for dynamic transformations of static HTML content directly on the edge, complementing Workers Sites and enabling JAMstack architectures with edge-side rendering. The API addresses limitations of previous methods that ingested entire response bodies, which impacted TTFB and prevented streaming.
Sep 2019Workers Sites: Extending the Workers platform with our own serverless building blocksIntroduced Workers Sites, a feature that allows deploying entire static websites to Cloudflare Workers. This is achieved by simulating a filesystem on top of Workers KV, where file paths are keys and file content is values. Wrangler CLI handles the upload of assets to KV and the creation of an asset manifest. The Worker script then uses this manifest to look up asset content hashes and fetch assets from KV. For performance, assets are cached on the edge after the first read per location, with cache busting handled by content hashes. This enables long-term caching of static assets, including HTML, reducing KV reads and improving performance.
Sep 2019Workers Sites: Deploy Your Website Directly on our NetworkIntroduced Workers Sites, a feature that allows developers to deploy entire static websites directly to the edge of Cloudflare's network. This leverages Cloudflare Workers and Workers KV to store and serve website assets, eliminating the need for traditional origin servers and CDN caching for static content. The deployment process is streamlined through the Wrangler CLI, which uploads assets to KV and generates a Worker to serve them with appropriate headers. This significantly improves performance by reducing latency and simplifies the developer experience by abstracting away configuration complexities.
Sep 2019The Technical Challenges of Building Cloudflare WARPThis post details the technical challenges encountered during the development of Cloudflare WARP, a product designed to secure and improve mobile device internet connections. It explains how WARP leverages Cloudflare's global network and ECMP routing, but faces issues with dynamic IP address and port changes due to cellular-to-Wi-Fi transitions and Network Address Translation (NAT). The post elaborates on the underlying network architecture, including Anycast IPs, routers, and the ECMP routing strategy, and explains the importance of TCP ports for distinguishing services. It also provides background on IPv4 address exhaustion and the role of NAT in managing limited IP addresses, setting the stage for how these challenges were overcome to ensure WARP's functionality.
Sep 2019How We Design Features for Wrangler, the Cloudflare Workers CLIThis post details the iterative design process for adding Workers KV functionality to the Wrangler CLI. It outlines three attempts at designing the command-line interface, highlighting lessons learned regarding command taxonomies, inspiration from other CLIs, and the importance of avoiding raw ID strings by leveraging the `wrangler.toml` configuration file for mapping human-readable names to KV namespace IDs. The final design uses colon-delimited command namespacing (e.g., `kv:namespace`, `kv:key`, `kv:bulk`) for clarity and explicitness.
Sep 2019Fast WordPress Sites with Bluehost & Cloudflare WorkersThis post details how Bluehost is leveraging Cloudflare Workers to improve WordPress site performance. They are using Workers to re-host and cache commonly run third-party scripts and dynamic HTML at the edge. This approach, building on the Fast Google Fonts example, aims to reduce latency and improve response times for WordPress sites, resulting in a reported 40% performance improvement.
Aug 2019Live Preview: Build and Test Workers Faster with Wrangler CLI 1.2.0This post details the development of the `wrangler preview --watch` feature for the Cloudflare Workers CLI. The author implemented a file system watcher using the `notify` crate to detect changes and trigger builds. A cooldown period was introduced to prevent excessive builds. Communication with the previewer was achieved using WebSockets connected to localhost. The feature was released in Wrangler v1.2.0.
Aug 2019Building a GraphQL server on the edge with Cloudflare WorkersThis post introduces `workers-graphql-server`, an open-source Apollo GraphQL server designed for Cloudflare Workers. It highlights the benefits of running GraphQL on the edge, such as low latency and fast deployments via Wrangler. A demo playground and a tutorial are provided for users to get started.
Aug 2019Magic Transit: Network functions at Cloudflare scaleThis post introduces Magic Transit, a new service that extends Cloudflare's edge network capabilities to the IP layer. It leverages Cloudflare's existing global network, anycast routing, and homogeneous server architecture to offer network functions like DoS mitigation, firewalling, and routing at scale. The post details the use of network namespaces for isolation and control of customer-defined network functions, and GRE tunneling over anycast for delivering traffic back to customer networks, effectively making Cloudflare's edge the customer's edge.
Jun 2019Continuing to Improve our IPFS GatewayIntroduced automatic cache purge for the IPFS gateway by checking DNSLink TXT records via DNS-over-HTTPS, bypassing cache if the record differs. Enabled beta testing for Orange-to-Orange (O2O) to allow layered zone configurations for IPFS gateway users. Implemented a subdomain-based gateway at cf-ipfs.com where subdomains are interpreted as content hashes, enabling immutable content serving. Enabled session affinity on the backend load balancer to direct requests from the same user to the same IPFS node, improving performance. Established persistent connections with Pinata for improved performance and reliability of content served from their network.
Jun 2019Enhancing the Optimizely Experimentation Platform with Cloudflare WorkersThis post details how Optimizely leverages Cloudflare Workers to improve performance and agility for its experimentation platform. For client-side A/B testing, Optimizely uses Workers to offload decision logic to the edge, returning a small amount of JavaScript to the browser for specific page loads, thus avoiding browser bottlenecks and FOUC. For server-side feature rollouts, Optimizely centralizes the instantiation of its JavaScript SDK within a Cloudflare Worker, which acts as a decision service. This Worker can be called from applications to determine feature enablement for a given user, reducing the need for origin server requests and simplifying full-stack implementation for applications relying on heavy caching.
Jun 2019Just write code: improving developer experience for Cloudflare WorkersIntroduced Wrangler, the official Workers CLI, for compiling Rust, C, and C++ to WebAssembly, creating single or multi-file JavaScript applications, installing NPM dependencies, adding KV namespaces and bindings, and publishing projects. Enhanced documentation with new tutorials for deploying Slack bots, QR code generators, and serving/caching files from cloud storage. Enabled multi-script deployment for breaking code into logical components. Launched workers.dev subdomains for deployment without a custom domain. Introduced a free tier allowing up to 100,000 requests per day. Improved the UI for a streamlined sign-up to deployment experience.
May 2019Building a To-Do List with Workers and KVThis post details how to build a full-stack to-do list application directly on the edge using Cloudflare Workers and Workers KV. It covers setting up a Worker to serve static HTML, writing and retrieving data from Workers KV, and dynamically rendering the data in the UI. The post emphasizes building applications without origin servers and leveraging Workers for global availability and low latency.
May 2019Workers KV — Cloudflare's distributed databaseThis post announces the general availability of Workers KV, a highly distributed, eventually consistent, key-value store designed to complement Cloudflare Workers. It explains the need for persistent data storage for Workers, details the CAP theorem trade-offs (Availability and Partition Tolerance over Consistency), and provides examples of use cases like mass redirects, user authentication, and configuration data. New features introduced include bulk writes for efficient data import and expiring keys for time-limited data storage.
May 2019Faster script loading with BinaryAST?This post introduces BinaryAST, a proposed over-the-wire format for JavaScript that aims to speed up parsing by using an efficient binary representation of the Abstract Syntax Tree (AST) and providing extra information to guide the parser. It details how BinaryAST addresses challenges like hoisting and lazy parsing by making scope information available upfront and allowing unused code to be skipped. The post also describes how Cloudflare enabled the encoder for BinaryAST to run on Cloudflare Workers, facilitating large-scale data collection on its impact.
May 2019Unit Testing Workers, in Cloudflare WorkersThis post introduces a method for executing Mocha unit tests directly within the Cloudflare Worker runtime by creating a compatible test harness. It details the directory setup, necessary npm packages (Mocha, Webpack, exports-loader, mocha-loader), example Worker script, test script, and the serviceworker-mocha-harness.js script. It also covers Webpack configuration for bundling and running the tests, and how to integrate this into a CI/CD pipeline, returning JSON test reports.
Apr 2019Rapid Development of Serverless Chatbots with Cloudflare Workers and Workers KVThis post details the development of a serverless chatbot using Cloudflare Workers and Workers KV to manage service ownership information. It outlines the requirements for the chatbot, including adding, querying, and deleting service ownership data, and demonstrates the implementation using the Command pattern and the Hangouts Chat API. The post highlights the benefits of reduced operational overhead and development time offered by Cloudflare Workers for such applications.
Apr 2019Eating Dogfood at Scale: How We Build Serverless Apps with WorkersThis post details the adoption and implementation of the Serverless Framework for managing Cloudflare Workers deployments. It covers setting up the `serverless.yml` configuration file for service name, provider details (accountId, zoneId), plugins, and function definitions (script, webpack, environment variables, resources like KV namespaces, and events/routes). It also discusses strategies for managing different deployment stages (development, production) using custom variables and external configuration files, and outlines unit testing approaches using Node.js frameworks like Mocha and Sinon.
Apr 2019Introducing WARP: fixing mobile Internet performance and securityIntroduced WARP, a technology integrated into the 1.1.1.1 App, to improve mobile Internet performance and security. WARP acts as a VPN for all app traffic, encrypting unencrypted connections and leveraging Cloudflare's network and a UDP-based protocol for speed and reliability. It is built on WireGuard for efficiency and aims to minimize battery usage. WARP+ is a premium version offering enhanced speed via Cloudflare's backbone and Argo technology.
Mar 2019? The Wrangler CLI: Deploying Rust with WASM on Cloudflare WorkersIntroduced `wrangler`, a CLI tool for building, previewing, and publishing Rust and WebAssembly Cloudflare Workers. This enables developers to use Rust and WebAssembly for Workers, leveraging V8 isolates for both JavaScript and WebAssembly execution at the edge.
Mar 2019A Full CI/CD Pipeline for Workers with Travis CIThis post details the setup of a Continuous Integration and Continuous Deployment (CI/CD) pipeline for Cloudflare Workers using Travis CI. It outlines the necessary files (Worker script, unit tests, serverless.yml, .travis.yml, .gitignore), provides example code for a simple 'Hello World!' Worker and its unit test using the cloudworker library, and explains the configuration of `serverless.yml` for deployment via the Serverless Framework. The `.travis.yml` file is presented with an explanation of its components for automating tests and deployments to the main branch. Finally, it covers the configuration of environment variables in Travis CI for authentication and deployment.
Mar 2019Writing an API at the Edge with Workers and Cloud FirestoreThis post details the architecture and implementation of a temporary subdomain reservation system using Cloudflare Workers and Cloud Firestore. It covers requirements for uniqueness constraints and blocklisting, a two-worker design for email verification and subdomain reservation, and the use of JWT authentication with Cloud Firestore's REST API. The use of Serverless Framework for managing Workers and node-jose for JWT generation is also discussed.
Mar 2019Unit Testing Worker FunctionsIntroduces Cloudworker, a mock for the Workers runtime, and demonstrates its use with Mocha for unit testing individual Worker functions and the overall Worker script. Provides an example script, directory setup, and test writing syntax.
Mar 2019A Node to Workers StoryThis post details the technical process of migrating a Node.js/Express application to Cloudflare Workers. It highlights the differences in request handling between Express (using `request` and `response` objects) and Workers (using `fetch` events and `respondWith` with `Response` objects). The author also describes creating a custom `app` object within the Worker to mimic Express routing logic and demonstrates how to replace `response.json()` with `new Response(JSON.stringify(...), { headers: { 'Content-Type': 'application/json' } })`. Furthermore, it showcases the removal of unnecessary configuration files like `Procfile`, `credentials.json`, and `package.json` by leveraging Workers' built-in capabilities and the ability to import libraries via webpack.
Mar 2019Diving into Technical SEO using Cloudflare WorkersThis post details the application of Cloudflare Workers for technical SEO, specifically focusing on implementing redirects and injecting Hreflang tags. It introduces strategies for managing large-scale redirects using Workers KV and Cuckoo Filters, and for efficient HTML parsing using a precomputed Boyer-Moore-Horspool algorithm over byte arrays and a Rust-based WebAssembly module. The post also outlines a filter chain architecture for composing request, response, and body modifications.
Mar 2019Deploying Workers with GitHub Actions + ServerlessIntroduced an official GitHub Action for Cloudflare Workers that integrates with the Serverless Framework. This action automates the deployment of Workers from GitHub repositories by running in a containerized GitHub environment and utilizing the Serverless Framework for deployment. It supports deploying individual Worker scripts and entire serverless applications.
Feb 2019Announcing workers.devIntroduced the workers.dev domain, allowing developers to deploy Cloudflare Workers to a subdomain without requiring an existing Cloudflare domain. This simplifies the onboarding process for new users and serverless projects. The workers.dev website itself is powered by Cloudflare Workers, showcasing its capabilities for serving static sites, A/B testing, and handling pre-registration APIs.
Feb 2019SEO Best Practices with Cloudflare Workers, Part 2: Implementing SubdomainsThis post details the implementation of a Cloudflare Worker to act as a reverse proxy, enabling the routing of traffic from a subdirectory (e.g., `bobtopia.com/blog`) to a remotely hosted service (e.g., `bobtopia.coolghosthost.com`). It provides example JavaScript code for handling HTML document requests and asset requests, demonstrating how to configure the Worker with target hostnames and asset pathnames. A caveat regarding asset pathnames sharing names with root domain routes is also discussed.
Feb 2019SEO Best Practices: Subdomains vs. SubdirectoriesThis post details how Cloudflare Workers can be used to implement a reverse proxy to convert subdomains to subdirectories for SEO purposes. It explains the technical setup required for both subdomains and subdirectories, highlighting the complexities of subdirectory setup with remote hosting and the relative ease of subdomain setup via DNS records. The post then introduces the use of Cloudflare Workers as a solution to bridge this gap, enabling the conversion of subdomains to subdirectories without requiring a traditional reverse proxy setup.
Feb 2019Solving Problems with Serverless – The Cloudflare LED Data Center Board, Part IThis post details the use of Cloudflare Workers and Workers KV to build a serverless API for a physical LED data center map. The architecture involves two Workers KV data stores and two serverless Workers deployed globally to provide updated data center status information to the map, even in challenging network environments at conferences and expo halls. The data stored includes data center details (city, lat/lon, status) and LED mapping information (strand, LED number).
Feb 2019IBM Cloud Internet Services protects any cloud – now with Cloudflare Spectrum and WorkersThis post announces the integration of Cloudflare Workers (referred to as 'CIS Edge Functions') into IBM Cloud Internet Services (CIS). This integration allows IBM customers to run custom JavaScript logic at the network edge across Cloudflare's global data centers, enabling use cases like request modification and outbound network requests. It also highlights the protection and acceleration of non-HTTP traffic with 'CIS Range' (likely related to Spectrum) and the introduction of 'CIS Enterprise Log Share' for enhanced analytics and forensics.
Jan 2019Introducing the Workers Cache API: Giving you control over how your content is cachedThis post introduces the Workers Cache API, which integrates with Cloudflare Workers to give developers programmatic control over Cloudflare's global cache. It allows for custom caching logic, including caching POST requests, and enables the cache to be used as a general-purpose key-value store, significantly enhancing performance and reducing origin server load.
Jan 2019create-cloudflare-worker: Bootstrap your Cloudflare WorkerIntroduced create-cloudflare-worker, a framework for bootstrapping Cloudflare Workers development. This framework provides a CLI for project initialization, local development server, Webpack integration for module support, Jest for testing, and automated deployment scripts via the Cloudflare REST API. It aims to reduce the time to get started with Cloudflare Workers.
Jan 2019Argo Tunnel + DC/OSThis post introduces the integration of Argo Tunnel with Mesosphere DC/OS, enabling secure and performant access to services running on DC/OS agents from the public internet via Cloudflare's network. It details how Argo Tunnel creates persistent outbound connections to Cloudflare PoPs, eliminating the need for inbound port openings, DNS configuration, or firewall rule modifications. The integration allows DC/OS users to leverage Cloudflare's DDoS protection, CDN, and TLS services for their applications, and enables global load balancing between DC/OS clusters across different cloud providers.
Jan 2019The SamKnows Cloudflare PlatformSamKnows leveraged Cloudflare Workers to deploy their internet performance measurement server software. This allowed them to gain immediate access to new measurement locations globally as Cloudflare expanded its network. The implementation involved rewriting the server-side software in JavaScript to run within the Workers environment, adhering to its resource limits (CPU time and RAM). The Workers implementation supported TCP download and upload speed tests, and round-trip latency/packet loss measurements (via ICMP, not UDP). Performance testing showed comparable or improved results compared to their existing dedicated servers in various markets.
Jan 2019Upgrading Cloud Infrastructure Made Easier and Safer Using Cloudflare Workers and Workers KVThis post details the implementation of a Cloudflare Worker script that intercepts incoming requests to a specific domain (webhooks.currentdomain.com). The script checks a Workers KV store (WEBHOOK_SETTINGS) to determine if a particular webhook endpoint (identified by its path) should be redirected. If enabled in KV, the Worker creates a new Request object with a modified hostname (webhooks.newinfrastructure.com) and forwards the request to the new infrastructure. If not enabled, the request is forwarded to the original infrastructure. The post also discusses debugging exceptions using Loggly and resolving 403 errors caused by IIS rate limiting by implementing Cloudflare Rate Limiting.
Dec 2018Improving request debugging in Cloudflare WorkersIntroduced a Network panel to the Cloudflare Workers inspector, mirroring Chrome DevTools' functionality. This panel allows developers to inspect request and response headers, raw responses, timings, and initiators for requests made by Workers to origins. It also supports exporting subrequests as HAR files. The implementation involved integrating with the DevTools Protocol, parsing JSON-RPC messages, and adapting the frontend to store response bodies on the client side to manage backend memory.
Dec 2018Cloudworker - A local Cloudflare Worker RunnerIntroduced Cloudworker, a local runtime for Cloudflare Workers that simulates Service Worker API, WebAssembly execution, and Workers KV. This tool enhances the developer experience by enabling local development and testing, reducing the iteration cycle for Workers.
Dec 2018Traffic Acceleration with Cloudflare Mobile SDKThis post introduces Traffic Acceleration with Cloudflare Mobile SDK, which uses novel transport algorithms built into the SDK to accelerate apps beyond TCP performance. It replaces TCP with a custom UDP transport protocol implemented on top of UDP, allowing for performance tuning, bug fixes, and incremental updates without kernel coordination. This leads to reduced latency, increased throughput, and improved app user experiences, demonstrated by a transportation company seeing a 7% decrease in network response time and a 13.8% drop in network timeouts.
Dec 2018OAuth Auth Server through WorkersThis post demonstrates a practical, stateful application of Cloudflare Workers by implementing a complete OAuth 2.0 authentication server. It highlights the use of Workers for handling complex workflows, integrating with external services, and leveraging Cloudflare Storage for state management, thereby pushing the boundaries of what can be achieved with serverless edge computing.
Nov 2018Serverless Progressive Web Apps using React with Cloudflare WorkersThis post demonstrates how to build isomorphic Progressive Web Apps using React with Cloudflare Workers. It shows how a single JavaScript bundle can be used for server-side rendering on Cloudflare Workers (using ReactDOMServer.renderToString) and client-side hydration in the browser (using ReactDOM.hydrate). It also details how to register a Service Worker using the same bundle to enable offline functionality and caching via the Cache API, effectively turning web pages into PWAs.
Nov 2018Fast Google Fonts with Cloudflare WorkersThis post details the implementation of a Cloudflare Worker to optimize Google Fonts performance by embedding CSS directly into HTML and proxying font files through the origin. This reduces round trips from 8 to 1, significantly improving perceived load times and ensuring correct font styling. The worker dynamically rewrites font URLs and caches them at the edge.
Nov 2018Introducing Apps with WorkersThis post announces the public beta of Cloudflare Apps with Workers, enabling developers to package and distribute their Workers scripts as Cloudflare Apps. This integration allows for the creation of more powerful app experiences, such as personalization, A/B testing, and custom security, directly within the Cloudflare Apps marketplace. It also outlines the process for building and submitting these integrated apps, including modifications to the `install.json` and an enhanced security review process.
Nov 2018Real URLs for AMP Cached Content Using Cloudflare WorkersThis post details the implementation of HTTP signed exchanges using Cloudflare Workers to enable real URLs for AMP cached content. It explains the technical challenges of serving cached content under origin URLs due to security and certificate requirements, and how HTTP signed exchanges, a component of Web Packaging, solve this by allowing third-party caches to serve content with proof of integrity and authenticity. The post outlines the cryptographic details of MICE (Merkle Integrity Content Encoding) and CBOR for generating signed exchanges and demonstrates how Cloudflare Workers can automate this process.
Nov 2018Cloud Computing without ContainersThis post introduces Cloudflare Workers, a serverless computing platform that does not use containers or virtual machines. Instead, it leverages V8 Isolates for lightweight, secure, and fast execution of untrusted code. The post details the advantages of this approach over traditional container-based serverless platforms, including significantly reduced cold start times, lower memory consumption, and improved cost-effectiveness. It highlights the security benefits derived from V8's robust sandboxing capabilities and the potential for running code closer to the metal.
Oct 2018Improving RubyDocs with Cloudflare Workers and Workers KVThis post details the integration of Cloudflare Workers and Workers KV to improve the RubyDocs service. A Cloudflare Worker was implemented to proxy requests from a subpath to a subdomain, consolidating the site onto a single domain for SEO benefits and a better user experience. Additionally, Workers KV was used to store and retrieve the latest version of Ruby projects, enabling the creation of 'latest version' URLs for improved DuckDuckGo bang integration. The Worker script itself is provided as an example.
Oct 2018Serverless Rust with Cloudflare WorkersThis post details the process of compiling Rust code to WebAssembly for use with Cloudflare Workers. It covers setting up the development environment using `wasm-pack`, generating a Rust WASM project from a template, and integrating it into a local browser-based test harness using `npm` and `webpack`. The post also highlights the challenges encountered with system calls like entropy generation in the `wasm-unknown-unknown` target and the need for careful consideration of host environment capabilities.
Oct 2018Custom Load Balancing With Cloudflare WorkersThis post demonstrates how Cloudflare Workers can be used to implement custom load balancing logic. It provides code examples for random routing, fallback strategies, and geographic routing based on the CF-IPCountry header, showcasing how developers can extend Cloudflare's capabilities to meet specific origin server routing needs.
Oct 2018Free to codeThis post announces the release of WebAssembly support for Cloudflare Workers, allowing developers to write code in languages other than JavaScript (e.g., Rust) and deploy it to the Cloudflare network. This expands the capabilities of the serverless platform and reduces friction for developers by enabling them to use their preferred languages.
Oct 2018WebAssembly on Cloudflare WorkersIntroduced support for WebAssembly (WASM) on Cloudflare Workers. Developers can now upload WASM modules and instantiate them within their Worker scripts. The post provides an example of dynamic image resizing using a WASM module and outlines the process for uploading WASM modules via the online editor or API. It also mentions plans to collaborate with Emscripten to streamline WASM module building for Workers.
Sep 2018Real World Serverless: The VideoThis post introduces Cloudflare Workers as a serverless platform that runs code globally at the edge. It contrasts different cloud computing models (on-premise, IaaS, PaaS, FaaS) and highlights Cloudflare's unique approach of deploying serverless functions to all edge locations instantly, eliminating the need to worry about specific data center locations. The talk emphasizes the benefits of bringing computation closer to the end user for reduced latency and cost, applying this concept to both IoT devices and websites.
Sep 2018Introducing Workers KVIntroduced Workers KV, a native key-value store for Cloudflare Workers. Values are available globally within seconds, encrypted at rest, in transit, and on local disk. Data can be written via the Cloudflare API or from within a Worker. Demonstrated use cases including serving an entire website ('originless'), shopping cart storage, A/B testing, authentication verification, and dynamic page construction. Provided example code for creating a Workers KV namespace and binding it to a Worker script.
Sep 2018Building With Workers KV, a Fast Distributed Key-Value StoreIntroduced Workers KV, a highly distributed, eventually-consistent, key-value store designed for Cloudflare's global network. It allows storing up to 1 billion keys (2kB each) with values up to 64kB, offering global consistency within 10 seconds and high read throughput (100k+ reads/sec/key). Pricing is integrated with Workers compute minimums, with additional storage and reads billed separately. Use cases include API gateways, dynamic data serving, configuration management, and connecting disparate systems.
Sep 2018JAMstack podcast episode: Listen to Cloudflare's Kenton Varda speak about originless codeThis post introduces Cloudflare Workers, a serverless compute platform that allows developers to run JavaScript code on Cloudflare's edge servers. It explains the core concept of receiving HTTP requests at the edge and executing arbitrary JavaScript code within a secure V8 sandbox. Use cases discussed include simple header rewrites, serving content directly from object storage without an origin server, personalizing cached content, implementing A/B testing, and running complex applications like Apollo Server for GraphQL at the edge.
Sep 2018Deploy Workers using TerraformThis post introduces the integration of Cloudflare Workers with Terraform, enabling infrastructure-as-code management for Worker scripts and routes. It details how to configure Terraform to deploy, manage, and version control Worker deployments, including setting up scripts and routes, and provides guidance on importing existing workers into Terraform management.
Sep 2018Build and Deploy Functions to Cloudflare’s 152+ Data Centers with ServerlessThis post introduces first-class support for Cloudflare Workers within the Serverless framework. It details how to define Worker scripts and routing behavior in `serverless.yml`, enabling deployment via `serverless deploy`. It also highlights `serverless invoke` for local testing and provides a basic `serverless.yml` example for a Slack bot. The post also mentions the `cloudflare-workers-enterprise` template for deploying multiple scripts.
Sep 2018Bob Ross, Lorem Ipsum, Heroku and Cloudflare WorkersThis post details the rapid deployment of a Bob Ross Lorem Ipsum generator using Cloudflare Workers. It showcases the process of launching a Worker, adding console output, implementing dynamic text generation from a JavaScript array, and serving an HTML UI. The author highlights the speed of deployment to 150+ data centers and compares the developer experience to Heroku. The code for generating phrases and serving the UI is provided.
Aug 2018Identifying and alerting on data loss using Cloudflare WorkersThis post introduces the use of Cloudflare Workers for data loss prevention by inspecting response bodies for sensitive data ('canary data'). It demonstrates how to read response text, construct a new response (including blocking responses with a 403 status), and trigger external alerts (PagerDuty) using `event.waitUntil()` for asynchronous notification. It also touches on integrating with Cloudflare Rate Limiting based on response headers.
Aug 2018Using Edge-Side Includes with Workers for High AvailabilityThis post details how Cloudflare Workers were used to implement Edge Side Includes (ESI) for high availability during a website migration. It showcases a practical application of Workers for partial page rewrites, allowing new frontend components to be gradually introduced while maintaining fallbacks to the existing WordPress backend. The post explains the technical implementation, including handling `X-Fragments` headers, prefetching fragments with timeouts, and streaming the response to replace fragments with prefetched content or fallbacks.
Aug 2018Using Workers To Make Static Sites DynamicThis post details the initial use cases of Cloudflare Workers for dynamic functionality on static websites. It introduces code examples for geo-targeting by reading the 'Cf-Ipcountry' header and redirecting to localized versions of sites. It also demonstrates restricting access to content by checking for a specific 'user-agent' header and implementing A/B testing by fetching and executing A/B testing scripts at the edge before rendering the UI, thus avoiding post-load JavaScript flicker. The post highlights Workers' advantages over client-side JavaScript and server-rendered sites in terms of performance and ease of integration.
Aug 2018Internet Native ApplicationsThis post defines the concept of 'Internet Native Applications' and outlines three key drivers for their emergence: 1) the increasing proximity of edge networks to end-users, making requests served from the edge feel 'local' and requests to centralized data centers feel like 'cache misses'; 2) the adoption of WebAssembly for near-native speed client-side code execution in browsers; and 3) the use of new performance-based protocols like QUIC and HTTP/2 for data exchange. It also discusses market implications, such as more services moving to the Edge and the commoditization of cloud services.
Aug 2018Integrating redirection.io with Cloudflare WorkersThis post details the integration of redirection.io with Cloudflare Workers. It provides example JavaScript code for a Worker that intercepts incoming HTTP requests, queries the redirection.io API for redirection rules, and either passes the request through or constructs a new response based on the redirection.io API's output. It also includes implementation details for logging and discusses performance considerations such as caching subrequests and setting timeouts.
Aug 2018Edge-Side-Includes with Cloudflare WorkersThis post introduces the implementation of Edge-Side-Includes (ESI) using Cloudflare Workers. It details how Workers can be used to dynamically fetch and combine content from different sources, enabling caching of static portions of a page while dynamically rendering dynamic fragments. The post provides a code example of a Worker that intercepts text-based responses, identifies ESI blocks, fetches the content specified in the `src` attribute of `<esi:include/>` tags, and merges it with the static content before sending the final response to the visitor. It also discusses the use of TransformStream for efficient streaming and the importance of `cache-control: max-age=0` for dynamic content.
Jul 2018Minecraft API with Workers + CoffeeScriptThis post details the development of a production-grade API for Minecraft player data using Cloudflare Workers. It outlines the problem of complex, multi-step API calls for fetching player profiles and avatars, and demonstrates how to consolidate these into a single Workers request. The implementation involves fetching UUIDs, player sessions, texture URLs, and finally the texture data, all orchestrated within a Worker. The post also covers setting up a CoffeeScript and Webpack development environment for Workers.
Jul 2018Proxying traffic to Report URI with Cloudflare WorkersThis post introduces a new use case for Cloudflare Workers: acting as a proxy to forward traffic to an external service (Report URI). It provides a concrete example of a Worker script that intercepts incoming POST requests, modifies headers (specifically User-Agent), and forwards the request body and modified headers to a specified origin. It also details how to configure the Worker to downsample report volume and hide the User-Agent string, showcasing the flexibility of Workers for custom request processing and integration.
Jul 2018Comparing Serverless Performance for CPU Bound TasksThis post benchmarks Cloudflare Workers against AWS Lambda and Lambda@Edge for CPU-bound tasks, specifically using PBKDF2 for password hashing. It demonstrates that Workers are significantly faster (up to 7x) and more cost-effective than Lambda, even when Lambda is configured with maximum memory. The tests also show that native binaries in Lambda do not offer a performance advantage over JavaScript for these types of workloads. The post highlights the global distribution of Workers as a key differentiator.
Jul 2018Debugging Serverless AppsThis post introduces a debugging technique for Cloudflare Workers by implementing an interceptor pattern. This pattern allows for pre- and post-processing of requests, enabling the capture of log lines and exception information. A LogInterceptor is detailed, which collects log messages and, when triggered by an 'X-Debug' header or '?debug' query parameter, appends them as a URL-encoded string to the response header. A bash function for decoding this string is also provided.
Jul 2018Serverless Performance: Cloudflare Workers, Lambda and Lambda@EdgeThis post provides a detailed performance comparison between Cloudflare Workers, AWS Lambda, and Lambda@Edge. It presents extensive benchmark data collected globally using Catchpoint, illustrating Workers' superior speed and lower latency, particularly at higher percentiles. The post hypothesizes that Workers' V8 isolate architecture, reduced memory footprint, and global deployment model are key factors in its performance advantage.
Jun 2018Cryptocurrency API Gateway using Typescript+WorkersThis post introduces a custom HTTP routing and handling framework built with TypeScript for Cloudflare Workers. It defines interfaces for routers and route handlers, and implements concrete routes for API gateway functionality: ping, aggregating responses from multiple providers, selecting the fastest response (using Promise.race), and direct passthrough. The implementation demonstrates building a cryptocurrency API gateway with less than 500 lines of code, highlighting the rapid development and deployment capabilities of Workers.
Jun 2018Delivering a Serverless API in 10 minutes using WorkersThis post introduces a Cloudflare Worker that acts as a serverless API endpoint. It takes a domain as input via a query string and checks if accessing it via HTTP results in a redirect to HTTPS. The Worker uses the `fetch` API to follow redirects and inspects the final URL. It also includes CORS headers to allow cross-origin requests and demonstrates basic error handling and response formatting. The post highlights the speed and simplicity of deploying such an endpoint using Workers.
Jun 2018Bootstrapping a Typescript WorkerThis post details the process of setting up a Typescript project for Cloudflare Workers. It covers local development setup using Webstorm, npm, and Jest for testing. It also introduces Grunt and the grunt-replace plugin to automate the transpilation of Typescript to Worker-compatible Javascript, including handling preamble comments, removing node-specific dependencies, and addressing `exports.__esModule` issues for the V8 runtime.
Jun 2018Using Webpack to bundle your Workers modulesThis post introduces the use of Webpack as a module bundler for Cloudflare Workers. It demonstrates how to configure Webpack with TypeScript and `awesome-typescript-loader` to bundle multiple JavaScript/TypeScript files into a single file suitable for deployment as a Worker. It also shows how to integrate npm modules like `path-to-regexp` into the Worker code. The post provides a complete example of a weather worker that uses routing logic and external API calls, all bundled with Webpack.
Jun 2018Building a serverless Slack bot using Cloudflare WorkersThis post details the technical implementation of a serverless Slack bot using Cloudflare Workers. It covers handling Slack webhooks, authenticating requests with a verification token, parsing user messages to extract stock symbols, making HTTP requests to the Alpha Vantage API, and constructing Slack-formatted responses. Key technical aspects include using `fetch` for API calls, leveraging `formData` for webhook payloads, implementing caching with `cf.cacheTtl` for performance and rate limiting, and structuring the Worker code with event listeners and helper functions. The post also touches upon best practices for secret management (SLACK_TOKEN, ALPHA_VANTAGE_KEY) and error handling.
Jun 2018DroneDeploy and Cloudflare WorkersDroneDeploy uses Cloudflare Workers to intercept image requests, validate JWT credentials, and then sign the URL with backend credentials before fetching from Google Cloud Storage. The Worker code demonstrates JWT parsing, signature validation using RSA public keys, and HMAC signing for Google Storage URLs.
Jun 2018Argo Tunnels: Spread the LoadThis post introduces the integration of Argo Tunnel with Cloudflare's distributed Load Balancing. It explains how Argo Tunnel allows applications to be deployed securely behind NATs or firewalls, and how load balancing can now distribute traffic across multiple Argo Tunnel instances. This enhances failure tolerance and performance for edge-deployed applications, with simplified management through the `cloudflared` agent.
Jun 2018Test New Features and Iterate Quickly with Cloudflare WorkersThis post introduces techniques for using Cloudflare Workers to implement feature gating and A/B testing. It details how to securely fetch and cache user permissions from an origin endpoint using the `fetch` method with a `cacheTtl`. It provides code examples for restricting access to specific API versions or documentation, implementing A/B testing by assigning users to different groups, and routing requests to different origins based on user permissions. The post also includes notes on caching sensitive objects and securely handling tokens.
May 2018Dogfooding Cloudflare WorkersThis post details the implementation of a Cloudflare Worker to intercept TLS connection information from incoming requests at the edge. The worker adds a custom 'X-Client-SSL-Protocol' header to requests forwarded to the origin, allowing backend services to react to outdated TLS versions. It also covers best practices for worker error handling, including `event.passThroughOnException()` for fail-open behavior and `event.waitUntil()` for asynchronous logging to Sentry.
Apr 2018mmproxy - Creative Linux routing to preserve client IP addresses in L7 proxiesThis post introduces mmproxy, a new tool that enables the preservation of client IP addresses for applications that do not natively support protocols like PROXY protocol. It details how mmproxy, in conjunction with Cloudflare Spectrum and Linux routing tricks (IP_TRANSPARENT, CONNMARK, and custom routing tables), allows for spoofing client IPs to target applications, effectively extending the reach of edge computing capabilities to legacy or non-standard applications.
Apr 2018Abusing Linux's firewall: the hack that allowed us to build SpectrumThis post details the technical challenges and solutions involved in enabling Cloudflare Spectrum, a feature that requires accepting TCP connections on any port from 1 to 65535. It explains how Cloudflare overcame Linux limitations by using the 'AnyIP' trick to assign large IP prefixes to the loopback interface and, crucially, by leveraging the obscure `TPROXY` iptables module and the `IP_TRANSPARENT` socket option. This allows the firewall to redirect packets to a local socket without changing the packet header, effectively enabling binding to any port without relying on `conntrack` or custom kernel patches. This technical deep-dive showcases how Cloudflare engineers push the boundaries of existing operating system capabilities to build new edge services.
Apr 2018Cloudflare Argo Tunnel with Rust+Raspberry PiThis post demonstrates the use of Cloudflare Argo Tunnel to expose a local Raspberry Pi web server (running a Rust Gotham web application) to the internet without opening firewall ports or configuring DDNS. It details the installation of the cloudflared agent, the authentication process using a Cloudflare domain, and the configuration to serve a dynamic Rust web application. It also touches on setting up the agent and web server to run on boot.
Mar 2018Everyone can now run JavaScript on Cloudflare with WorkersThis post announces the general availability of Cloudflare Workers, a serverless JavaScript execution platform on Cloudflare's edge network. It details the core capabilities, including intercepting and modifying HTTP requests/responses, running code globally, and leveraging the V8 engine for fast execution (under 1ms). It also outlines deployment speed (under 30 seconds globally) and pricing ($0.50 per million requests). Examples of use cases and a code snippet are provided.
Feb 2018Using Cloudflare Workers to identify pwned passwordsThis post introduces the implementation of a Cloudflare Worker that intercepts POST requests, extracts a 'password' field, calculates its SHA-1 hash, and checks the first 5 characters against the Pwned Passwords API range. If a match is found for the remaining characters, a 'Cf-Password-Pwnd: YES' header is added to the request before it's forwarded to the origin. The Worker also includes basic error handling and demonstrates the use of `crypto.subtle.digest` for hashing and `fetch` for subrequests.
Feb 2018Cloudflare Workers is now on Open BetaThis post announces the open beta of Cloudflare Workers, enabling developers to run JavaScript on Cloudflare's edge network across over 120 data centers. It highlights the ability to intercept and modify requests, make outbound calls, and replace CDN configurations. The post provides instructions for getting started, links to documentation and recipes for common use cases like A/B testing, conditional routing, request filtering, response aggregation, and hotlink protection. It also mentions the availability of a GitHub repository for examples and a community forum for feedback.
Sep 2017Code Everywhere: Why We Built Cloudflare WorkersThis post introduces Cloudflare Workers, a new platform for running JavaScript code at the edge, close to end-users. It explains the motivation behind Workers as a 'third place' for code execution, bridging the gap between device and server code. The post highlights the use of JavaScript for its flexibility and the ability to update code globally in seconds, turning Cloudflare from a service into a platform. It emphasizes the low latency and update speed as key differentiators.
Sep 2017Introducing Cloudflare Workers: Run JavaScript Service Workers at the EdgeThis post introduces Cloudflare Workers, a new platform for running JavaScript at the edge, inspired by the Service Worker API. It allows developers to write code that intercepts and modifies HTTP requests globally, offering use cases for performance enhancement (custom caching logic, edge-side includes), security (custom WAF rules, authentication), and reliability (fast fixes, custom load balancing). The platform leverages V8 for secure JavaScript execution and is accessible via a playground.
Aug 2017The Languages Which Almost Became CSSThis post explores the historical development of styling languages for the web, predating CSS. It details proposals like RRP, ViolaWWW's stylesheet language, FOSI, and DSSSL, highlighting their features and why they didn't become the standard. It also touches on the early challenges of styling HTML and the eventual adoption of CSS. The post connects these historical developments to the current landscape of web development and the ongoing evolution of styling capabilities.
Aug 2014CloudFlare Now Supports WebSocketsIntroduced WebSocket support for Enterprise and select Business customers, enabling bidirectional, real-time communication. Addressed challenges with long-lived connections by expanding the ephemeral port range to 56,512 ports per source IP and implementing SO_REUSEADDR to allow ports to be reused more aggressively, significantly increasing the number of concurrent connections to origin servers.
Feb 2013Facebook Bug Redirects the Web Through Javascript Widget ErrorThis post details how Cloudflare's Rocket Loader feature can mitigate risks associated with third-party Javascript widgets acting as single points of failure. It explains that Rocket Loader optimizes Javascript loading and includes failsafes to prevent widgets from hijacking pages, thereby improving site availability and security. It also mentions Cloudflare Apps as a way to centrally manage and remove problematic widgets.