gpu-driven rendering

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.

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.

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.

Brian Bucklew of Freehold Games discusses design decisions behind Caves of Qud and Sproggiwood at IRDC 2015. The talk centers on data-driven, event-driven engine design.

SpaceX engineers present at NVIDIA's GPU Technology Conference on a multi-physics code that simulates the full-scale Raptor methane engine. It covers GPU-based turbulent combustion modeling with adaptive grids and wavelet compression.

Martin Fowler's GOTO Chicago 2017 talk on the different things people mean by event-driven architecture. He identifies four patterns, including event notification and event-carried state transfer.

Emily Shea explains how repetitive strain injury pushed her to program by voice using speech recognition (Talon), and gives a live coding demo. She argues voice-driven development can be pain-free, efficient and enjoyable.

Edwin Brady, creator of Idris, presents Idris 2 and demonstrates type-driven development, where the compiler assists by filling holes and suggesting implementations from types.

Edwin Brady, creator of Idris, introduces type-driven development in a dependently typed language. He shows types being written first and programs derived with interactive editing, then extends beyond simple examples to programs that interact with users and networks.

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.

Scott Wlaschin shows how statically typed functional languages, using F# examples, can model a business domain so that invalid states cannot be represented. The type system acts almost like an instant unit test at compile time.

Rik Arends presents Makepad, a Rust UI framework, at RustNL 2023. The talk covers designing modern, GPU-fast UIs with Rust and includes live-coded demos of an IDE and a synthesizer.

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.

Greg Young, who coined CQRS, looks back on a decade of domain-driven design, CQRS and event sourcing at DDD Europe 2016. He discusses where event sourcing applies and how simple its core can be.

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

Nadia Polikarpova's Strange Loop talk on program synthesis driven by refinement types, as in Synquid. It shows how rich type specifications can be turned into verified, executable code.

Elias Martenson presents his Emacs-based workflow for building a web application (the Potato chat platform) with Common Lisp on the backend and ClojureScript on the frontend. He demonstrates SLIME, Paredit, CIDER and debugger-driven interactive development. The talk is 79 minutes and was given at Emacs SG.

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.

Olivier Giroux's CppCon 2019 talk recounts the roughly ten-year effort to bring std::atomic and the C++ memory model to CUDA GPUs, through ten stories from that work.

Rafal Dittwald's Clojure/north talk shows how to move from writing Java-style code in Clojure to thinking in data-driven, functional terms. He walks through a JavaScript example, refactoring imperative code step by step into a functional core.

Rich Hickey's philosophical talk from the first Clojure Conj in 2010. He argues that good design comes from deliberate, away-from-keyboard thinking, and describes how to feed the background mind so it solves problems.

Ryan Dahl, the creator of Node.js, introduces the event-driven I/O framework built on V8 with examples, and discusses the v0.4.0 release and its new APIs.

Steven Wittens' JSConf US 2013 talk on drawing with WebGL, using animated visuals to walk through vectors, matrices and the rendering pipeline. Despite the title, it works as a visual primer on the linear algebra behind 3D graphics.

Matt Adereth's Clojure/conj talk covers the history of keyboards and how he used Clojure generating OpenSCAD to design and build his custom Dactyl ergonomic keyboard, including 3D printing and laser-cut parts.

Yaron Minsky of Jane Street shows how the OCaml Incremental library lets trading UIs express data transformations that are easy to read and efficient on streaming data. It includes a live table demo.

James Trunk introduces Clojure syntax and thinking, covering its core data structures, immutability, the thread-last macro and live data analysis in the REPL.

Walt Disney Animation Studios' short introduction to path tracing, showing how rays are traced and bounced through a virtual scene to simulate light. It explains how this approach is used in animated films.

A one-minute capture of Tim Clarke's 1993 'Mars' DOS demo, a roughly 5 KB program that renders a navigable terrain landscape in real time.

A GDC 2015 talk by Arc System Works technical artist Junya Motomura on how Guilty Gear Xrd rebuilt a classic 2D fighter in full 3D while keeping a hand-drawn look. It covers the art and programming R&D and the stylistic decisions behind it.

A Thoughtworks conversation among Martin Fowler, Kent Beck and David Heinemeier Hansson on whether TDD is dead. They discuss the tradeoffs of test-driven development, mocking and where TDD helps or hurts design.

minimme traces the timeline of 3D graphics engines on the Game Boy Advance, from early experiments to commercial 3D games, covering techniques such as voxel rendering. It is a history and showcase of what developers coaxed out of the limited hardware.

Jim Coplien and Bob Martin debate test-driven development and unit testing in an InfoQ video that grew out of a JAOO 2007 dispute. They also touch on design and architecture.

A Computer History Museum demonstration with Dan Ingalls of Smalltalk-76 running on a Xerox Alto, recorded in 2017. He shows the live environment and discusses the system.

Acerola explores building a shader that turns games into ASCII art, walking through techniques such as brightness mapping and edge detection to see whether it looks good.

Linus Tech Tips tests whether chaining many PCIe riser extensions causes loss of GPU performance. They keep adding extensions to see how far the signal will go.

Modern Vintage Gamer explains why PlayStation 1 graphics warped and jittered, comparing it with the Nintendo 64. The causes are affine texture mapping and the lack of sub-pixel vertex precision.

A video showing a virtual camera built in Blender that simulates lenses and film layers using path tracing, to make physically modeled photographs.

Richard Feldman's elm-conf talk on designing models so that bugs from impossible application states cannot occur, using Elm's compiler and types. It demonstrates techniques for making invalid states unrepresentable.

Ian Cooper's DevTernity talk revisits Kent Beck's original TDD ideas and shows where misunderstandings crept in. It argues tests should target behaviors through public interfaces rather than implementation details, so suites support refactoring instead of resisting it.