Topic
Everything filed under Performance, newest first.
RSS · JSON · All topics
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
Jim Calabro walks through how bloom filters work, how Bluesky moved from multiple hash functions to double hashing to cut contention, and then explores the one-hash bloom filter from Lu et al., which splits the bit array into partitions with pairwise coprime sizes so a single hash can stand in for k independent ones.
6 min · 1,387 words
Does Moving a GPU Server's Request Loop into the Kernel Save CPU?
Eunomia tested bpf-gpu-server, which lets eBPF and io_uring own a GPU server's TCP path so no user thread touches a request. Against an efficient epoll baseline its CPU use and latency matched; the post explains where per-request cost really goes and what actually moved the numbers.
9 min · 2,015 words
Faster than earcut: triangulating 3.7M map polygons in 489 ms
Evgen Bodunov of Globus Software explains how the GLMap engine's polygon triangulator, now open-sourced as earstrip (one C++ header plus a WebAssembly npm build), beats earcut: 14% faster in C++ and 1.4–2.1x faster in the browser, covering convex shortcuts, triangle strips and branch-free counting.
17 min · 3,810 words
Hyper Optimizing Kimi K3 in vLLM: Moving Fast and Responsibly
The vLLM team and NVIDIA describe using coding agents to build a unified CuTe DSL decode path for Kimi K3 on NVIDIA GB300, reaching over 840 tokens/s at batch 1 on 16 GPUs, and the guardrails (isolated changes, correctness tests, reproducible benchmarks) used to land agent-written kernels responsibly.
10 min · 2,277 words
Superoptimizing an FPU Emulator
purplesyringa wanted a branch-free way to compute the lowest set bit of a float for a floating-point emulator library, and instead of hand-deriving it wrote a small superoptimizer that searched instruction sequences and found a surprisingly clever rewrite.
4 min · 974 words
Postgres DELETE Can Actually Scale
DBOS explains how Postgres actually deletes rows and how it made workflow retention deletes scale: batched deletes of the oldest workflows, dropping foreign keys so tables are cleaned in phases, debugging a 20-minute index lookup, and why it chose DELETE over dropping partitions.
7 min · 1,532 words