Compile-Time Code Generation & Metaprogramming

6/4/2026

This post announces the acquisition of VoidZero, the company behind Vite, Vitest, Rolldown, and Oxc. It highlights Cloudflare's commitment to keeping these projects open-source and vendor-neutral, and outlines plans to invest engineering resources and a $1 million ecosystem fund into their development. The post details how Cloudflare is integrating these tools into its own platform, particularly by moving its CLI and application tooling towards a Vite-centric experience, and leveraging the Vite Environment API to run server code locally within the Cloudflare Workers runtime (workerd). It also emphasizes the growing importance of these tools for AI-generated code and the evolution of Vite into a full-stack development tool.

2/24/2023

This post details the development of ROFL, a new NGINX module written in Rust to replace the legacy cf-html component. It explains the motivation for the rewrite, focusing on memory safety improvements and performance gains by using the lol-html Rust library. The post provides technical details on how to generate FFI bindings between NGINX and Rust using Bindgen and discusses the use of NGINX's dynamic module loading. It highlights the deprecation of a critical and historically problematic piece of code (cf-html) and the provision of a robust system for response body parsing and rewriting.

10/10/2022

This post delves into the concept of tail calls, both in traditional compilation (e.g., Fibonacci implementations) and specifically within the eBPF (extended Berkeley Packet Filter) ecosystem. It explains how tail call elimination optimizes recursive functions by reusing stack frames, contrasting 'okay' vs. 'cool' implementations. The core of the post focuses on BPF tail calls, detailing the `bpf_tail_call` helper, its use in chaining BPF programs (e.g., for XDP-based packet processing), and the historical limitations on arm64 regarding the co-existence of BPF tail calls and BPF-to-BPF function calls. It clarifies that BPF tail calls are an implementation of tail call elimination, reusing the same stack frame, rather than a program replacement mechanism, and explores the nuances of how they interact with BPF function calls and stack frames.

8/26/2021

This post introduces and explains Rust's `Pin` and `Unpin` types, detailing their necessity for safely handling self-referential types and futures in asynchronous programming. It covers the concept of Futures, the dangers of self-referential types leading to memory unsafety, and how `Pin` and `Unpin` provide a safe mechanism for managing these types, particularly in the context of async Rust libraries.

9/24/2020

This post details the development of a performance benchmarking framework for Cloudflare's Wirefilter engine, inspired by Rust compiler benchmarks. It covers the use of hardware counters and perf_event_open for detailed performance measurement, including CPU time and memory usage. The post also discusses strategies for speeding up benchmarks, such as deduplication, sampling, and partitioning of filters. Finally, it delves into optimizations for the `contains` operator, exploring the use of Rust's regex library and SIMD-accelerated string searching algorithms to improve performance.

3/4/2019

This post details the design of Cloudflare's open-sourced Rust library for Wireshark-like filters, 'wirefilter'. It explains the decision to use manual parsing over parser generators due to the need for contextual parsing of ambiguous syntax (e.g., IPv6 addresses vs. byte sequences). It also describes optimizations to the execution engine, specifically replacing HashMap lookups with fixed-size array indexing for field access by resolving field names to indices during parsing and storing them in the AST, resulting in approximately 2x speed improvements.

12/12/2018

This post details a year-long project with King's College London aimed at improving LuaJIT performance. It highlights the creation of a robust benchmark suite to address inconsistencies in existing Lua benchmarking, the comparison of original LuaJIT with RaptorJIT, and the presentation of detailed performance results for both, along with a comparison of their differences. This contributes to the understanding and optimization of dynamic language performance at the edge.

1/31/2018

This post introduces a detailed tutorial on writing complex macros in Rust, using Reverse Polish Notation (RPN) as a practical example. It demonstrates how to leverage Rust's macro system for compile-time evaluation by converting RPN expressions into infix notation. The tutorial covers matching tokens with `tt`, recursive macro invocation for state management (stack simulation), handling operators, and basic error handling strategies using `trace_macros`. It provides runnable code examples and links to playgrounds.

12/8/2012

This post introduces the use of Lua with Nginx (specifically via ngx_openresty and LuaJIT) as a method for extending Nginx's capabilities without custom C modules. It highlights Lua's suitability for embedding, its asynchronous nature inherited from Nginx, and its performance benefits. An example of Nginx log aggregation using Lua is provided, demonstrating how Lua can be used for tasks like calculating request times and aggregating them in shared memory. The post also discusses limitations and recommended practices for network communication within this environment.