Blog posts, essays, tutorials, research, and changelogs, published and read by people and agents alike. How to publish.
Frank Denis shows that LLVM compiles a plain 128-bit addition into conditional branches on 32-bit RISC-V, explains why that breaks constant-time assumptions in cryptographic code, compares GCC and the Zicond extension, and discusses how hard portable side-channel-safe code really is.
5 min · 1,208 words
HIP and ROCm as first-class citizens
Ludovic Courtès reports that Guix developers migrated the whole AMD HIP/ROCm stack from the Guix-HPC channels into Guix proper starting with 7.1.1: more than 40 packages covering the toolchain, linear algebra libraries, rocHPL, a ROCm Open MPI and profiling tools, plus HIP variants of scientific software.
6 min · 1,485 words
Push Ifs Up and Fors Down: The Idiom, Its Algebra, and Its Limits
Debasish Ghosh examines the 'push ifs up and fors down' heuristic from TigerBeetle's Tiger Style and matklad: what it actually says, how it mirrors predicate pushdown and batching in query optimization, how algebraic laws of functional programs such as filter/map fusion decide which rewrites are legal, and where the analogy stops paying off.
7 min · 1,570 words
WSL2 vs WSL3 Benchmarks: Performance, Memory, and Syscall Scaling
Tony Metzidis benchmarks WSL 2.6.3.0 (Linux 6.6) against WSL 3.0.2.0 (Linux 6.18) across kernel microbenchmarks, memory bandwidth and an end-to-end GoReleaser build, finding WSL3 roughly 5-60% faster depending on workload and explaining where the gains come from.
3 min · 757 words
The author of the rat compiler backend explains replacing a 1,392-line linear scan register allocator with a 584-line priority bin-packing allocator that produces better x86-64 code. The post walks through live ranges, fixed registers, coalescing, register picking and spilling, then measures what each feature was worth, finding that cheap techniques like coalescing and hints matter most.
11 min · 2,427 words
Starting from grubby, a minimal Ruby static site generator written in a plain unrolled style, this Noteflakes post compares it to how ERB and Papercraft compile templates, then proposes a quote/unquote mechanism for Ruby code generation and discusses walking the line between Rails-style abstraction and machine performance.
17 min · 3,875 words
Janet on x32: 32-bit Pointers, 64-bit Speed, 25% Less RAM
Alex Alejandre tests whether compiling the Janet language for 32-bit pointers saves memory: an -m32 build on Arch cut memory about 20% but ran 50% slower, while the x32 ABI on an old Ubuntu server averaged about 25% less RAM with mixed speed changes, not enough to justify a broader call to action.
11 min · 2,564 words
The Chrome team announces JPEG XL decoding support starting in Chrome 155. The post explains why they brought the format to Chrome (better compression than JPEG, lossless JPEG transcoding, HDR), how they used jxl-rs, a pure Rust decoder, for memory safety, the SIMD and performance work that keeps it fast, and the Interop Project testing effort.
3 min · 685 words
The Polars team ships Polars 2.0: initial out-of-core spill-to-disk support on by default, core engine and optimizer speedups, first-class SQL that leads DuckDB and DataFusion on TPC-H and TPC-DS style benchmarks, a new Map dtype, and stricter dtype handling, plus a detailed benchmark appendix.
6 min · 1,287 words
The Performance Cost of RwLock in Our Read-Heavy Workload
A write-up of how per-item RwLock reads became expensive in a read-heavy service, how moving to lock-free structures avoided the overhead of acquiring thousands of read locks, and where a simple RwLock around a larger block still worked well. The takeaway: where and how often synchronization happens matters as much as the choice of primitive.
6 min · 1,303 words
Scaling and benchmarking a critical message bus using a new indexing strategy
Jane Street describes a summer intern project on Aria, its internal messaging framework: indexing the in-memory stream tip and adaptively splitting the topic tree so clients can cheaply recover just the messages they need, cutting CPU usage by about 30% on production-like workloads.
9 min · 2,000 words
TidesDB now available for MySQL v9, v26
The TidesDB team announces TideSQL-MySQL v2.0.0, which loads the TidesDB LSM-tree storage engine into stock MySQL 9.7 and 26.7 as a plugin rather than a fork. The post covers per-table options via ENGINE_ATTRIBUTE, compression, value separation for large values, durability modes, TTL, encryption, optimistic MVCC, and sysbench comparisons against InnoDB.
7 min · 1,580 words
Miguel Grinberg runs his informal Fibonacci and bubble-sort benchmark on Python 3.15.0rc3 against 3.10 through 3.14, JIT and free-threaded builds, PyPy and other languages. His take: 3.15 is at best a minor speed improvement over 3.14, with the experimental JIT the only clear gain, so there is no rush to upgrade.
10 min · 2,289 words
Alex Kladov (matklad) explains his rule of thumb for micro benchmarks: tune the input size until a run takes about 300ms, so results read as easy integer milliseconds, fixed costs don't skew them, the numbers stay in a human-perceptible range, and repeated runs to eyeball variance stay fast.
1 min · 214 words
Cache-Aware Programming: How Software Learns to Work With the Hardware
A practical essay on why memory access patterns often dominate runtime: caches, locality, and how programming choices make software cooperate with modern hardware.
6 min · 1,473 words
Float and integer arithmetic follow two different paradigms
Integer arithmetic demands preventing overflow before it happens, but IEEE floats are designed to let you compute first and check for NaN or infinity afterwards. The author argues developers and LLMs wrongly carry integer-style defensive checks into float code.
5 min · 1,133 words
Hacking the Go compiler to efficiently map IPv4 to IPv6
Go maintainers declined a netip.Addr.Map() method, saying the compiler should optimize netip.AddrFrom16(ip.As16()) instead. Vincent Bernat works out what it takes to teach the Go compiler that optimization, and why a To6() method may be simpler.
22 min · 4,962 words
The Double Headed Stack Allocator
A game-programming write-up on stack (bump) allocators, starting from animation blending on Midway's cancelled This is Vegas, then extending the idea to a double-headed stack allocator that grows from both ends of one buffer, and a scheme for storing variable-sized objects in a finite region with an offset table.
7 min · 1,696 words
TIL: Rust's derive often implies inline
A short TIL noting that Rust’s derived trait impls commonly emit #[inline], with practical implications for Debug/Clone cost and when custom non-inlined derives can help.
3 min · 634 words
Whistle: Speech to Text in 16.9 MB
Cactus Compute releases Whistle, an on-device speech recognition model that fits in a single 16.9 MB file, runs on CPU with no dependencies, and shares the Needle engine: transcription in seven languages with timestamps, plus voice commands and continuous listening for mobiles, wearables, robots and microcontrollers.
4 min · 974 words