Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
Billion-query-per-second lookup tables in C++
Daniel Lemire shows how to replace std::unordered_map for small, compile-time-known string sets (HTTP methods, headers, keywords) with a constexpr perfect hash, cutting each lookup to a single comparison and about five cycles, and shares a single-header C++ library and benchmarks built with Francisco Geiman Thiesen of Microsoft.
5 min · 1,221 words
SIMD-accelerated computer vision on a $2 microcontroller
shranav describes writing a FAST corner feature detector for the ESP32-S3 using its little-known 128-bit SIMD instructions, working around misaligned reads and signed-only saturating arithmetic, and roughly doubling throughput to about 11.2 megapixels per second, around 6ms per QVGA frame.
4 min · 994 words
We should be more ambitious with the software we build
Dan Luu argues that AI coding tools let skilled engineers attempt far more ambitious software, using Michael Malis's pgrust (a Postgres rewrite with JIT-style optimizations whose testing has surfaced real Postgres bugs) as the running example, and explains why programming expertise still matters for judging model output.
27 min · 6,109 words
Memory is slow, Disk is fast - Part 3
Jared Hulbert benchmarks an on-disk sorted-set structure (DiskArray on 8 NVMe drives, 264 MiB RAM) against an in-RAM AVL tree at 2 billion keys and finds the disk-based design faster at search, rank, insert and delete, arguing Big O misleads and that memory must be treated like a parallel, pipelined block device.
19 min · 4,345 words
Xiangpeng Hao introduces bbtree, a zero-dependency Rust B-tree that he reports is 5x faster than std's BTreeMap on one thread and 12x faster than crossbeam-skiplist at 96 threads, explains how it cuts cache misses and coherence traffic, and describes how the LLM-written code is kept correct with human review, formal verification, deterministic simulation and fuzzing.
19 min · 4,484 words
OrgWebAlchemy: Benchmarking, Profiling, and the Long Road to Real Org Support
Josep Bigorra details how the Guile OrgWebAlchemy Org-mode parser gained Markdown output, figures, named elements and table rows, and got up to 6.4x faster after profiling uncovered a quadratic collapse pass and a per-character scanner.
26 min · 6,059 words
Software is slow because of bad design, not slow languages
Sean Goedecke argues that rewriting programs in C or Rust (with or without AI) rarely makes them much faster: most software is I/O-bound, slow languages already delegate hot paths to fast libraries, and real speedups come from redesign.
5 min · 1,229 words
Brotli on NGINX thread pools: ngx_mbrotli vs ngx_brotli
Mikhail Panfilov benchmarks ngx_mbrotli, which runs on-the-fly Brotli compression on an NGINX thread pool, against google/ngx_brotli, measuring p99 latency for other requests, requests per second, large-response speed, CPU time and memory, plus configuration advice.
16 min · 3,701 words
How close can pure FP get to C?
Richard Feldman takes up the lean-zip versus libdeflate result and explores how far a DEFLATE implementation in Roc, a pure functional language, can be pushed toward C performance, with benchmarks, compiler work, and reproduction scripts.
41 min · 9,413 words
Postgres recovery_prefetch Considered Harmful and Causing Outages
Jeremy Schneider describes a field investigation showing that Postgres's recovery_prefetch setting can quietly cause standby replay lag and production outages, tracing it back to a concern raised on the hackers list years ago and explaining what he found.
5 min · 1,253 words
Objects, attributes, maps, oh my!
Max Bernstein walks through how dynamic language VMs move from hash-table objects to hidden classes (shapes or maps) and inline caches, with Python sketches and notes on how ZJIT handles polymorphic shapes in Ruby.
13 min · 3,019 words
Using a lookup-table to correct an approximation
A corsix.org post on compiling enum-to-string functions compactly: instead of a switch or a full offset table, compute a fast but incorrect approximation of each string's offset and fix it with a small table of corrections, a general trick compilers still miss.
4 min · 827 words
Max Bernstein on Rails at Scale shows how Rails enum predicate methods were made dramatically faster by generating static code at runtime instead of dynamic public_send dispatch, with benchmarks and lessons about fixing performance upstream.
3 min · 788 words
Don't throw it all away: Caching an immediate-mode UI
How Blick's UI Painter keeps pixels it has already rendered, combines shapes and opacity groups, and saves work behind an immediate-mode UI, with measurements of CPU, GPU, and battery impact.
17 min · 3,914 words
2026 is an exciting year for the Rust compiler (and me)
Rust compiler contributor Matyáš Racek surveys long-running rustc efforts paying off in 2026, including the next-generation trait solver, Polonius, the parallel frontend nearing stabilization, LLVM and micro-optimization speedups, move elimination, polymorphization, Cargo cache and build-dir changes, and reflections on the Rust All Hands.
11 min · 2,539 words
Putting Linux on my RTX Spark laptop because I don't have a Microsoft account
Josephine Pfeiffer gets Arch Linux ARM running on the Windows-only ASUS ProArt P16 with NVIDIA's N1X chip, publishing a bootable installer and patches, comparing CPU performance against Windows in 7-Zip, explaining the 116 GiB unified memory split, and benchmarking local Qwen inference.
6 min · 1,453 words
Diffusion at Scale: Introducing Mercury 3
Inception introduces Mercury 3, a diffusion-based LLM more than 40x larger than Mercury 1 that it says matches or beats speed-optimized frontier models while running at over 1,000 tokens per second, with a 1M-token context, low per-token pricing, and early production use in browser agents, tutoring, search and support.
4 min · 888 words
Making dns_erlang Fast: Binary Tricks for the BEAM
Nelson Vides of DNSimple explains how binary pattern matching, append-friendly accumulators, staying in the match context, chunked matching and SWAR cut CPU per query in their Erlang name server erldns by 12%, what didn't work, and lessons for any BEAM application.
17 min · 3,980 words
A Very Fast IPv4 Parser, in Swift
Mahdi Bahrami presents a new IPv4 parsing algorithm built for swift-endpoint that uses SWAR tricks instead of lookup tables, SIMD or out-of-bounds reads, explains why existing fast parsers' contracts don't fit Swift, and benchmarks it at around 3 nanoseconds, ranking second on Apple M6 and third on AMD Zen 5.
14 min · 3,226 words
Andrea Piseri looks at how array languages like APL implement scans over packed boolean arrays, where a naive loop manages about 0.6 elements per cycle. Using truth-table symmetries, the essay shows that fast versions of just and, less-than and xor are enough to derive good implementations of every other boolean scan, with bit-twiddling implementations in an appendix.
14 min · 3,251 words