rendering performance

A one-minute NVIDIA research demo of foveated rendering for VR using SMI eye tracking. It renders at full detail only where the eye is looking, matching the physiology of human vision.

A Graphics Programming Conference talk on how the game Tiny Glade renders meadows, trees and player-built castles. It covers real-time global illumination, tilt-shift depth of field, stable shadows with continuous time of day, ray marching and GPU-driven rendering on old hardware.

A Netflix performance engineer presents how Netflix tunes EC2 instances, covering instance type choice, Xen modes, SR-IOV and kernel tuning. The goal is near bare-metal performance in the cloud.

Ryan Florence's React.js Conf 2015 talk pushes React into unusual use cases, including a demo comparing rendering in React, Ember and Angular.

Chandler Carruth's CppCon 2014 talk on writing fast C++, explaining why data structure choice and memory layout matter more than clever algorithms. It covers why standard containers like unordered_map perform poorly on modern CPUs.

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 Google Tech Talk on Yahoo's 14 rules for faster web pages and the YSlow tool. It covers front-end practices like avoiding @import and fixing ETags, with live analysis of popular sites.

Malte Skarupke's C++Now 2018 talk on hash table performance, explaining why std::unordered_map is slow and memory hungry and presenting faster designs, including his bytell hash map.

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.

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

A Remedy engineer explains how Alan Wake 2 moved to a GPU-driven rendering pipeline built on mesh shaders, culling and rendering meshlets for dense vegetation on PS5 and Xbox Series consoles.

Brian Karis's SIGGRAPH 2021 talk explains how Unreal Engine 5's Nanite virtualized geometry works. It covers mesh import, the data structures, streaming, decompression, culling, software and hardware rasterization, and shading.

Emery Berger explains why performance is hard to measure and deliver on modern hardware, showing how code layout and alignment can swamp optimization effects. He presents Stabilizer for statistically sound evaluation and Coz, a causal profiler.

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.

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.

Alex Russell's Chrome Dev Summit 2016 talk on building web experiences that work on slow, flaky networks and low-power devices. It argues developers should focus on the performance of real-world mobile hardware rather than desktop machines.

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.

Dan Abramov's JSConf Iceland talk on what came after React 16, with live-coded prototypes of async rendering and time slicing. It previews the ideas that became concurrent mode and suspense.

Chandler Carruth walks through tuning C++ performance, from writing benchmarks to analyzing results on real CPUs and compilers. It focuses on small-scale problems such as loop kernels, data structures and algorithms, and on keeping compilers from optimizing benchmarks away.

Cliff Click walks through a small performance example on a modern out-of-order CPU. He covers pipelining, ILP, CISC vs RISC, multicore, and why cache misses and the memory subsystem dominate performance.

A 2009 Google Tech Talk by Nicholas Zakas on the hidden performance pitfalls of JavaScript. It covers what is fast and slow in the language and how to avoid common bottlenecks.

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.

An excerpt from a Bay Area Rust meetup on Servo's WebRender, which renders CSS display lists on the GPU at very high frame rates. It explains the approach and demos rendering at around 500 FPS.

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.

Chandler Carruth's CppCon 2016 talk on designing hybrid data structures for performance. He covers cache locality, working-set size and allocation overhead, and why standard C++ containers fall short.

Euclideon's 2011 technology preview of Unlimited Detail, a rendering approach claiming unlimited geometric detail in real time via point-cloud style data. The company promised more to come while keeping most work secret.

A short side-by-side recording by Jake Archibald of the same animation demo running in Chrome, Firefox, Safari and Servo WebRender nightlies on a 60Hz display. It shows the smoothness difference of GPU-based rendering.

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.

Bisqwit builds a Doom or Duke Nukem 3D style software-rendered 3D engine in C from scratch, supporting non-Euclidean geometry. It covers vector rotation and portal rendering with sped-up, tool-assisted coding.

Optiver's Carl Cook explains how to build high-frequency trading systems in C++, where the critical path runs rarely but must be extremely fast. He covers techniques for low and predictable latency, including avoiding main memory and cache misses.

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.

Aaron Hsu shows how to manipulate and transform tree data in APL using arrays and inverted tables instead of pointers. He claims much smaller code, better performance and easier parallelisation.

A Tiny Desk concert in which pianist Dan Tepfer plays with a Disklavier player piano driven by a program he wrote that responds to his playing. He performs four pieces from his Natural Machines project.

Jafar Husain of Netflix explains at React.js Conf 2015 how Netflix runs React-style rendering without the DOM on smart TVs and game consoles. It uses a canvas-like API for performance.

A GDC 2015 talk in which Natalya Tatarchuk describes the multithreaded renderer Bungie built for Destiny. It covers the low-latency architecture across platforms, its successes and its challenges.

A solo performance of Steve Reich's Piano Phase, with one pianist playing both parts, recorded in 2004 with Reich in attendance. It is a 15-minute minimalist phasing piece.

Ilya Grigorik of Google's Make the Web Fast team explains how to build a mobile site that appears on screen within one second. He covers the network and rendering constraints on mobile.

The Who performing Won't Get Fooled Again at Shepperton Studios in 1978, filmed for The Kids Are Alright. It was Keith Moon's last performance with the band.

Mike Acton of Insomniac Games argues that a program's purpose is transforming data, and shows how common C++ approaches work against that in performance-critical game development. He covers cache behavior, data layout and the limits of compilers.

Media Molecule's Alex Evans recounts the journey, including the failures, of finding the Dreams engine, based on his Siggraph 2015 talk. It covers the signed-distance-field and splat-based rendering approach and the artistic goals behind it.