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.

Tutorial · Hardware · Performance · Systems Programming

One Hash Bloom Filters

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.

Tutorial · Algorithms · Data Structures · Performance · Programming

JPEG XL vs AVIF for web use-cases

Jake Archibald compares JPEG XL and AVIF for web delivery after JPEG XL landed in major browsers: compression efficiency, decode/encode cost, progressive rendering, animation, HDR, and when each format wins for typical site images.

Tutorial · Web Development · Performance · Images · Compression

PGO or not PGO this is the dilemma. Step 2Step 2: How it works

The second of Marco Tusa's three-part Percona series on profile-guided optimization explains how PGO works as a two-pass build: instrumented binaries record per-edge control-flow counters during a training workload, and the compiler then uses those counts for inlining, branch layout, hot/cold splitting and code ordering, which is why MySQL's MTR test suite transfers well as training data.

Tutorial · MySQL · Databases · Compilers · Performance

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.

Tutorial · Programming · Performance · Linux

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.

Tutorial · Performance · Programming · Systems Programming · Tutorials

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.

Tutorial · Programming · Performance · Systems Programming

What Makes LLM Tokenization Slow?Exploring the performance of byte-pair encoding by optimizing a GPT-2 tokenizer.

Andrew Healey dissects GPT-2’s reference BPE tokenizer, measures what makes tokenization slow, and shows concrete optimizations on the hot path of LLM products.

Tutorial · LLMs · Programming · Performance · AI

Optimizing x264 Settings and Per-title Ladders

Jan Ozer shows how to tune x264 encodes and per-title bitrate ladders to cut bandwidth while improving quality—practical encoder settings and ladder design for H.264-heavy streaming workflows.

Tutorial · Performance · Tutorials · Programming

Differences between foldl and foldr

The Haskell blog preserves Alexis King's widely used explanation that foldl and foldr differ in associativity rather than traversal direction, covering lazy versus strict folds, why foldl' is usually right for strict accumulation, when foldr suits lazy or short-circuiting work, and when foldMap is the better choice.

Tutorial · Programming · Tutorials · Performance

How Forge Structures Requests for Prompt Cache Reuse

Mohit Ranka explains how Forge, an open-source terminal-first AI IDE, restructures its agent harness requests—stable prefixes, message ordering, history persistence and cache hints—to maximise provider prompt-cache reuse, and how request snapshots plus usage tracking make cache behaviour observable.

Tutorial · LLMs · AI Agents · Developer Tools · Performance

SDF vs. MSDF vs. Slug: GPU Text Rendering

Chris Hanson compares SDF, MSDF, Slug, texture atlases, and Rive for GPU text: how signed-distance fields trade sharpness, memory, and shader cost when you draw outlines yourself.

Tutorial · Graphics · Programming · Hardware · Tutorials

Writing Rust code that's faster than state-of-the-art libraries by asking agents to make the code faster

Max Woolf shows how iterative agentic coding—prompting agents to repeatedly speed up Rust code—produced solutions faster than established libraries, with concrete methodology and caveats.

Tutorial · Rust · Programming · AI Agents · Performance

The query finished… Why is my Fabric SQL database still consuming CUs?

Two minutes of SQL database activity in Microsoft Fabric can mean ~17 minutes of compute billing. Nikola Ilic walks through CU metering with application, development, and troubleshooting examples.

Tutorial · Data Engineering · Databases · Cloud Infrastructure · Performance

When the fractional part of a float fixes your shader

Bruno Croci debugs a Voronoi Shadertoy stutter that only appeared on a Windows RTX 4070: ANGLE/FXC optimizations dropped `fract` for integer-looking inputs, and swapping a literal to `398.1` or using `x-floor(x)` restored smooth motion.

Tutorial · Programming · Hardware · Debugging · Performance

From OpenGL to Vulkan

Alexandre Lamure walks through first-principles differences when porting a small OpenGL engine to Vulkan—bindless resources, explicit synchronization, and modern Vulkan 1.3 patterns—with pointers to nebula and further reading.

Tutorial · Programming · Hardware · Tutorials · Engineering

How sparse resources helped my GPU-driven renderer memory usage

A deep dive into using sparse/reserved GPU resources (D3D12-focused) to manage memory for GPU-driven renderer data structures like dynamic and bit arrays.

Tutorial · Programming · Hardware · Performance · Engineering

Use 20x less peak RAM with dp_knapsack_sliding_hirschberg, a new activation memory budget solver for PyTorch

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.

Tutorial · Machine Learning · Algorithms · Performance · Open Source

Writing Efficient C++ Code

A practical guide to writing C++ that actually uses the machine well—covering language and hardware basics, common pitfalls, and habits that keep hot paths fast without premature micro-optimization theater.

Tutorial · C++ · Programming · Performance · Systems Programming

Gallery of Processor Cache Effects

Igor Ostrovsky's classic 2010 post uses short C# code samples to illustrate how processor caches shape real program performance: memory access patterns, cache lines, L1 and L2 sizes, instruction-level parallelism, cache associativity, false sharing of cache lines, and hardware quirks that are hard to explain.

Tutorial · Performance · Hardware · Systems Programming · Programming