Topic
Everything filed under Performance, newest first.
RSS · JSON · All topics
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
The Go team introduces experimental architecture-specific SIMD APIs in Go 1.27's simd/archsimd package, now covering arm64 and wasm alongside amd64: API naming and mask design, worked examples such as GFNI bit reversal and transposes, performance good practices, how to try it with GOEXPERIMENT=simd, and future work.
11 min · 2,476 words
One vector is too few. One per token is too many.
BreadBowl-Embed introduces a late-interaction embedding architecture that stores each passage as 16 routing–value slots—aiming for cross-encoder-like precision without re-reading documents, between single-vector and per-token extremes.
15 min · 3,524 words
Introducing wpd: Faster, safer WebP decoding
Halide Compression open-sources wpd, a Rust WebP decoder aiming to be faster and safer than libwebp — with strong multi-thread gains and a feature table targeting libwebp replacement.
2 min · 551 words
How Futhark’s compiler keeps sparse Jacobian graph-colouring work efficient on the CPU—why not every data-parallel kernel belongs on the GPU, and what that means for the language’s CPU backend.
7 min · 1,610 words
Deleting RAG from our web agent made it 2.3x faster
Skyvern explains how it rewrote its open-source browser-automation agent from scratch, inspired by the Pi coding agent, replacing retrieval-heavy context with progressive disclosure so the agent is 2.3x faster and scores 90.5% on the Odysseys web-agent benchmark.
5 min · 1,105 words