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 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.

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 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.

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.

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.

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.

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.

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.

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.

A full performance of Steve Reich's Music for 18 Musicians by eighth blackbird with Third Coast Percussion and others, recorded in Chicago in 2011. It is an hour-long minimalist piece built on phasing and repeating patterns.

Chandler Carruth shows how to squeeze more performance out of already-optimized C++ code, covering how the CPU executes it. The talk goes into pipelining, branch prediction and speculative execution using benchmarks.

Jack Moffitt presents the architecture of Servo, Mozilla's experimental browser engine written in Rust, focusing on parallelism across cores, GPUs and SIMD and the safety properties gained from Rust.

A CppCon 2018 talk arguing that OOP has failed to deliver on reuse and performance, and presenting data-oriented design for C++ with practical worked examples from real systems.

A demo of Marble Marcher, a game using a fractal physics engine and fully procedural ray-marched rendering. The player rolls a marble through shifting fractal levels.

Dave Chinner's linux.conf.au 2012 talk on XFS scalability, covering pain points with large numbers of files and complex metadata, and the work to fix XFS metadata performance.

Matt Godbolt builds a toy path tracer in C++ in three different styles and compares them on clarity, testability, compile time and run-time performance. The talk was given at CppCon 2019.

Tom Dale explains the internals of the Glimmer VM, Ember's rendering engine, which compiles templates to opcodes. The talk includes a performance benchmark demo.

The Academy's 2014 Sci-Tech Awards segment honoring Matt Pharr, Greg Humphreys and Pat Hanrahan for their physically based rendering work and book. The authors give a short acceptance speech that thanks Donald Knuth for literate programming.

A one-minute clip of Rochus Keller performing as a one-man band: slap bass with the left hand, Rhodes and lead guitar with the right, and drums with the feet.

David Ditzel of Esperanto Technologies presents their massively parallel, energy-efficient RISC-V processors at the 7th RISC-V Workshop in 2017. It covers the high-performance many-core design aimed at machine learning.

Aaron Patterson's RailsConf 2011 talk on Rails 3.1 performance, showing why deeper Rack middleware stacks slow Rails and how a shallower pipeline helps. It also touches on Rack API design.

A very short clip from Star Trek: The Next Generation's 'Peak Performance' in which Picard says it is possible to commit no mistakes and still lose. It is a single quotable moment about how outcomes are not fully in your control.

A short scene from Star Trek TNG season 2, episode 'Peak Performance', in which Picard tells Data that it is possible to commit no mistakes and still lose. He says that is not a weakness but life.

Andrei Alexandrescu's CppCon 2019 talk revisits sorting, showing how branchless tricks, hybrid strategies and a cost metric can speed up std::sort-style algorithms on modern hardware.