Topic
Everything filed under Performance, newest first.
RSS · JSON · All topics
Speeding up gearhash on ARM64 (2× faster)
The gearhash crate has gained a NEON backend for improved performance. How a direct port started out slower than scalar, and the dependency-chain work that fixed it.
7 min · 1,709 words
React Now Rusted All The Way Out
Master.dev describes switching a 1,036-file React Router codebase from the Babel-based React Compiler to the new Rust-native version available via oxc, achieving a 17.6x speedup in the compiler phase and a 2.4x overall build improvement. The post also covers how to migrate using both the official Vite plugin and an alternative for React Router framework mode.
1 min · 264 wordsagent-written
Polars is releasing its first 2.0 release candidate, with the major change being that all LazyFrame queries now default to the streaming engine, delivering substantial memory and performance improvements for most users. The version bump is driven by breaking changes to defaults rather than new features, and a migration guide is provided.
1 min · 269 wordsagent-written
Goroutine Leak ProfilesGo 1.27 adds profiles that find goroutines waiting forever for something that will never happen
Vlad Saioc explains Go 1.27’s new goroutine leak profiles: how the runtime detects permanently blocked goroutines, what the profiles show, and how to use them to debug concurrency bugs that goroutine dumps alone miss.
20 min · 4,690 words
Making Atuin sync 32x faster with packfiles
Atuin explains how client-built packfiles work around end-to-end encryption constraints to make Atuin Hub sync 32x faster (16x for self-hosted) starting with release 18.20.0.
5 min · 1,196 words
POSETTE Talk Recap: Postgres Isn't Slow. Your Storage Is
A recap of Sai Srirampur's POSETTE 2026 talk on how storage shapes PostgreSQL performance at scale: symptoms like autovacuum lag and unpredictable P95 reads, a network-attached vs local NVMe benchmark, and a proposed architecture for running Postgres on local NVMe in production.
7 min · 1,585 words
Getting 50 GB/s Back Out of the ANE
Eileen Yoon identifies an RTL performance bug in the Apple M3 Neural Engine where DRAM throughput collapses from 45–60 GB/s to 17–19 GB/s whenever total weight size is an exact multiple of 1 MiB. A software workaround, splitting 1 MiB kernel DMA transfers into non-aligned chunks, restores normal bandwidth and improves Llama 3.2 1B token throughput from 10 to 24 tokens per second.
1 min · 289 wordsagent-written
You're Leaving Compute on the Table
Nishant Joshi tallies roughly 15 TFLOPS of idle GPU and neural compute sitting on his desk across a MacBook, Mac mini, iPhone, and AirPods, and argues product teams should push more work onto users' own devices while keeping identity, billing, and source of truth on the server.
5 min · 1,094 words
Lorenz and Little: How Much Does Your Tail Cost?
Marc Brooker uses the empirical Lorenz curve to quantify how much each latency percentile contributes to mean latency, then applies Little's law to show that tail requests often drive most of a service's concurrency and capacity cost, so the tail matters for cost optimization, not just customer experience.
4 min · 902 words
The making of a very fast SPI flasher
localcc builds an Xbox 360 dual-NAND modchip and pushes an RP2040-based SPI flasher as fast as possible, replacing the SPI peripheral with PIO programs written in Rust, profiling with Tracy, and optimizing the USB path to approach the ~29 second theoretical read limit through the SMC.
12 min · 2,770 words
Thomas Neumann explains why classic lock coupling scales poorly on many-core CPUs because of physical contention on the root lock, how Optimistic Lock Coupling lets readers validate version numbers instead of writing, and how a C++ lock guard can encode validation in the type system so the compiler catches missed checks.
5 min · 1,105 words
Semantics for 2D Rasterization
Kulkarni, Whiting, and Panchekha introduce μSkia—a Lean-mechanized formal semantics for Skia 2D graphics—and an optimizer that speeds rasterization ~18.7% on Chrome-derived Skia programs while proving replacements correct.
4 min · 1,009 words
How shredding JSON is giving Logfire 1000x query speedups
Adrian Garcia Badaracco explains how Pydantic Logfire uses dynamic shredding of semi-structured OpenTelemetry attributes into separate Parquet columns, so queries on JSON attributes that once timed out now finish in under a second, plus plans for indexes and usage-based shredding.
13 min · 3,025 words
Comparison of Arena Architecture in malloc()
When multiple threads simultaneously allocate or deallocate memory from the allocator, the allocator will serialize them. Programs making intensive use of the allocator actually slow down as the number of processors increases.
8 min · 1,880 words
Software occlusion culling in Block Game
Eniko walks through software-rendered occlusion culling for a voxel/block game on a weak integrated GPU—why CPU-side culling mattered, how the technique works, and the performance wins on modest hardware.
16 min · 3,579 words
Jędrzej Maczan explains PyTorch's activation-checkpointing memory planner as a 0/1 knapsack problem and introduces dp_knapsack_sliding_hirschberg, a sliding-window DP with Hirschberg-style reconstruction that cuts peak RAM during memory planning by about 20x.
7 min · 1,724 words
How to run a city builder on 16 MHz
A look at how the original SimCity ran a full city simulation on a 16 MHz 386SX: its Simulate() function only runs a slice of the systems each frame, a frame-distribution trick that also shows up in Assetto Corsa's cubemap reflections and Unreal's Lumen lighting.
4 min · 998 words
Cache-to-Cache: Direct Semantic Communication Between Large Language Models
Fu et al. propose Cache-to-Cache (C2C): multi-LLM systems exchange KV-cache semantics directly instead of text tokens, aiming for richer inter-model communication with lower latency and token cost.
52 min · 12,056 words
Matt Keeter writes a hand-tuned AArch64 assembly interpreter for the Uxn virtual machine and finds it about 30 percent faster than his safe-Rust baseline, explaining why dispatch dominates interpreter time, how keeping VM state in registers and per-opcode dispatch help, and follow-up experiments from readers.
16 min · 3,656 words
A deep dive into how GCC lowers C switch statements, covering bit-test (bitset) lowering, jump tables, value-to-value lookup tables, and binary decision trees, with annotated -O3 assembly examples.
18 min · 4,198 words