cache optimization

Casey Muratori's first refterm lecture lays out philosophies of optimization, distinguishing optimization from non-pessimization, which means avoiding needless work. It uses his fast terminal renderer project to show how fast computers really are.

Netflix engineer Drew Gallatin's EuroBSDcon 2022 talk quantifies the older FreeBSD optimizations that let Netflix serve web traffic at 800Gb/s, including TSO, LRO, VM page cache zones, asynchronous sendfile and unmapped mbufs.

Kaze Emanuar explains how he rewrote and optimized the Super Mario 64 source code so it runs far faster on real N64 hardware. He covers performance bottlenecks and fixes in detail for his ROM hacks.

Matthias Wandel tests old and new code on a range of PCs, including a new mini PC, to measure how much faster modern hardware really is. He also shows optimization techniques such as branchless code, with benchmark programs on GitHub.

Kaze Emanuar searches for the best sine approximation for the Nintendo 64, comparing the lookup tables in Mario 64 and Ocarina of Time with polynomial alternatives. It walks through numerics and 3rd, 4th and 5th order approximations.

Matt Parker follows the community effort to speed up his slow Wordle-solving code, which ended up running hundreds of millions of times faster. He walks through the techniques contributors used.

Andrew Kelley, creator of Zig, presents practical data-oriented design techniques for shrinking memory footprint and making programs cache friendly. He ends with a case study of how these ideas sped up the Zig compiler.

Modern Vintage Gamer examines the claim from the Super Mario 64 decompilation project that the game shipped unoptimized, and puts it in the context of 1996 N64 development.

In Ars Technica's War Stories, Naughty Dog co-founder Andy Gavin explains how the team squeezed Crash Bandicoot onto the original PlayStation. They overwrote Sony library code in RAM, built custom animation compression, and streamed assets around slow seek times.

Casey Muratori shows how fast a terminal renderer can run, building a simple reference renderer that handles Unicode and colored text far quicker than Windows Terminal. He argues that common excuses for slow terminals do not hold up.

Casey Muratori's University of Twente guest lecture is a case study in how straightforward code can cut thousands of lines and tens of seconds of runtime down to a few dozen lines running in under a second. It uses concrete examples to show why software is often an order of magnitude slower than it should be.

Casey Muratori shows how typical 'clean code' object-oriented patterns can cost large factors in performance. He benchmarks them against simpler data-oriented code.

Emery Berger argues that performance is hard to measure and deliver on modern systems, showing how code layout and link order can swamp optimization effects. He presents tools that evaluate performance more reliably.

Charlie Marsh of Astral explains how uv, a Rust Python package manager, got so fast. He covers allocators, concurrency, zero-copy tricks and the challenges of Python packaging.

Aaron Boodman of Replicache asks why sync engines have not yet fixed web app complexity and what is missing for them to go mainstream. The talk lays out the ideas that led to the Zero sync engine.

Casey Muratori's two-hour talk tracing the history of object-oriented programming back to the 1960s and examining how its ideas, and later entity component systems, came about. It is followed by a Q&A.

Richard Feldman explains how pure functional languages can match or beat imperative ones on performance. Compilers can turn immutable code into in-place mutation, avoiding naive copying. The talk draws on his work on the Roc language.

Khalil Estell's CppCon 2024 talk argues C++ exceptions can reduce binary size in firmware. He digs into how exceptions work and how to shrink their code footprint on embedded platforms.

Wes Bos breaks down the techniques behind the McMaster-Carr website's speed: server-rendered HTML, prefetching, CDN and service worker caching, preloading, critical CSS and fixed-size images. He also notes its old-school jQuery and YUI JavaScript.

Casey Muratori follows up his refterm proof-of-concept, a GPU-based terminal renderer, with a second part covering memory usage, glyph sizing and correct Unicode and VT handling. It is built to show that a terminal can be fast and correct without heroic effort.

A walkthrough of the Quake III fast inverse square root, explaining where the constant 0x5f3759df comes from. It covers IEEE 754 floats, the bit hack that approximates a logarithm, and a Newton's method refinement.

Casey Muratori responds on-stream to a dismissive Twitter post by demonstrating how slow Visual Studio's startup and debugger watch window are, comparing it to much older software and machines. It is a long rant about software performance and bloat.

Robert Collins explains why rustup installs were painfully slow on Windows and how changes to rustup and Windows cut install time from 3m30s to 14s. The talk covers NTFS, small files and the cost of antivirus hooks on file close.

A Zig SHOWTIME talk by Benjamin Feng on what a memory allocator is, followed by an interview. It covers allocation strategies and different allocator types in Zig.

Daniel Lemire's QCon talk on how simdjson parses gigabytes of JSON per second. It covers SIMD vectorization, branch prediction and the lessons learned building a fast parser.

Alexis King's ZuriHac 2020 talk on how effect systems in Haskell can be implemented efficiently. It looks at the performance cost of effect libraries and how to reduce it.

MattKC fits a playable Snake game into a QR code by writing tiny x86 machine code and patching the ZBar scanner so it can run the decoded data.

Leptos creator Greg Johnston examines Rust/WebAssembly frontend frameworks against JavaScript frameworks using the JS framework benchmark. He argues that WASM is no longer too slow for DOM-heavy rendering.

Dennis Gustafsson, creator of Teardown, presents how he parallelized the physics solver for an upcoming game, followed by a Q&A. The talk was given at the Better Software Conference 2025.

Emery Berger's CppCon 2020 plenary on why performance is hard on modern hardware after the end of Dennard scaling. It covers benchmarking pitfalls and introduces new profiling tools for finding real bottlenecks.

Anders Hejlsberg introduces the native port of the TypeScript compiler, written in Go, which promises roughly 10x faster tooling. He demos compiling VS Code and explains where the speedup comes from.

Brandt Bucher presents his prototype JIT compiler for CPython at the 2023 Core Developer Sprint. He explains the copy-and-patch approach, the implementation and its performance.

Casey Muratori's invited lecture on where bad code comes from, rebroadcast from a Twitch stream. He critiques conventional wisdom such as SOLID and Clean Code and argues about how those habits lead to slow, poorly structured software.

Tom 7 (suckerpinch) delivers a long, comedic digression on gradient descent and floating-point imprecision. He shows how rounding behavior can supply the nonlinearity needed to build a neural network.

A ten-minute clip from Jonathan Blow's talk on preventing the collapse of civilization, arguing that software quality and the knowledge to build it are in decline.

2kliksphilip examines UserBenchmark, a hardware comparison site known for strongly biased, pro-Intel writing. The video explains the site's credibility problems and points viewers to better sources for CPU and GPU information.

Digital Foundry investigates why Resident Evil Village on PC runs worse with Capcom's Denuvo DRM than a cracked version. They benchmark and confirm performance and frame-pacing differences.

Casey Muratori's remastered BICFest 2018 talk on how the collision system of The Witness was engineered to prevent whole classes of bugs found in game engines. It covers character movement and collision handling.

Chandler Carruth's CppNow 2023 talk on modernizing compiler design for the Carbon toolchain, using data-oriented design and modern hardware assumptions. It covers lexing, parsing and compact data structures aimed at compiler performance.

A React Conf talk by Xuan Huang previewing React Forget, a compiler that automatically memoizes components. It argues for making memoization the default so developers need not write useMemo or useCallback by hand.