Mighty Professional
Gaming
AAA dev gone indie — long-form, hands-on tutorials on the systems behind games, graphics, and ML.
Tutorials
Fifty tutorials in the hub's phase order. Foundations is optional depth to pull in when a later module leans on it; two playable milestones sit in the path, a complete 2D game and then a 3D one. The hub page carries the full dependency graph.
Foundations
Big O Notation
The language game programmers use to predict whether a system survives the jump from test scene to shipping content. Four worked engine case studies (broad-phase collision, BVH ray traversal, A*, draw-call sorting), the master theorem, and a live in-browser playground.
Bit Shifting
Two's complement to BMI2. The signed-division trap, shift-count UB, and why hand-writing a shift for speed buys nothing. Then the engine payload: flags and bitsets, bitboards, RGBA packing, Morton swizzling, fixed-point, the Quake III inverse square root, xorshift, and hardware popcount. Fourteen live widgets and primary sources from HAKMEM 1972 to C++20.
C++ Containers
The standard containers engine code leans on: vector, deque, list, map, unordered_map, the adaptors, the views. Memory pictures, complexity proofs, and a live race that measures how far node-based containers fall behind vector.
Hash Tables from Scratch
The O(1) lookup behind entity maps, asset registries, string interning, and shader variant caches. Chaining, linear probing, Robin Hood, Swiss tables with SIMD metadata, and what deletion and resizing cost. Seven live widgets, including three erase policies racing on one op stream until the tombstone table runs out of empty slots, and a stop-the-world rehash whose worst single operation touches 65 slots next to an incremental one that never exceeds five.
Sorting Algorithms
The sort routines that ship inside real engines and language runtimes: introsort, pdqsort, timsort, powersort, radix, bitonic. The n log n lower bound, the 2015 timsort stack-invariant bug, branchless partitioning, and three engine case studies including draw-call sort keys.
x86-64 Assembly from Scratch
The CPU model your compiler is actually targeting: sixteen GPRs, the VEX/EVEX encoding, System V vs Microsoft x64, branchless code, SIMD math, μops and port pressure. Six live widgets including a register-file stepper, an instruction-encoding decoder, and a branchy-vs-branchless race.
Memory & concurrency
The C++ Memory Model from Scratch
Cache coherence, store buffers, the memory orderings, false sharing, ABA, hazard pointers, and a Chase-Lev deque that stays correct on ARM. Seven live widgets and a litmus-test playground.
Memory Allocators from Scratch
The allocators engines ship: linear/bump, stack, pool, buddy, TLSF, slab. Fragmentation, AoS vs SoA, generational handles. Ten live demos, cited primary sources, and the 1965 paper Linux's page allocator still descends from.
Job Systems from Scratch
Build a dependency-tracking, work-stealing job scheduler in C++ and Rust, then look at the fiber design Naughty Dog shipped in The Last of Us Remastered. Eleven live widgets and an in-browser scheduler playground.
SIMD from Scratch
SSE, AVX, AVX-512 and NEON for game code: SoA vs AoS, multiple accumulators to hide FMA latency, pshufb as a parallel lookup table, masking, and what gather really costs. Six live widgets, a frustum cull at 8 spheres per AVX2 iteration, and a sourced read on AVX-512 clock behavior.
Lock-free Queues & Memory Ordering
The queues the job pool and the audio thread need, in C++ and Rust: the progress taxonomy (lock-free vs wait-free), the SPSC ring that needs no CAS, Vyukov's bounded MPMC, the ABA problem and reclamation, and why code that's correct on x86 breaks on ARM. Three live widgets, including an SPSC ring and an ABA demonstrator.
Math & numerics
3D Math for Games
Vectors, matrices, and quaternions from scratch in C++ (glm) and Rust (glam), then the conventions that actually bite: row vs column major, left vs right handed, and Vulkan's Y-down, zero-to-one clip space. Five live widgets, including a gimbal-lock rig and a SLERP-vs-NLERP race, plus why your first triangle renders upside down.
IEEE-754 Floating Point
Floating point from the bits up, in C++ and Rust: the binary32 layout, subnormals, NaN and signed zero, round-to-nearest-even, ULP, Kahan summation, FMA, why -ffast-math breaks things, and cross-platform determinism. Four live widgets, including a clickable bit-field editor and a Kahan-versus-naive summation race.
The runtime spine
The Game Loop & Time
The loop that drives the whole engine, built from the naive version up. Variable versus fixed timestep, the accumulator, render interpolation (and why it is not extrapolation), the spiral of death, and determinism. Three live widgets, parallel C++ and Rust, and the Unity, Unreal, and Godot loops as case studies.
Platform & Window: the OS Event Loop
The platform layer in C++ and Rust: opening a window, pumping the OS event queue (and why you must, or the OS calls you hung), poll loops (SDL/GLFW) versus event-driven callbacks (winit), plugging in the fixed timestep, and handing a surface to Vulkan. Two live widgets, including a message pump you can starve into "Not Responding".
Input Systems (HID)
Game input from scratch in C++ and Rust: events vs per-frame sampling, scancodes vs keycodes (so WASD survives AZERTY), raw mouse and pointer lock, gamepads across XInput/DirectInput/SDL/gilrs, the dead-zone shapes that actually work, response curves, action maps, and input buffering. Three live widgets, including a dead-zone explorer and an input-buffer timeline.
Resources
File Streaming for Game Engines
Build a working game-engine streamer in C++ and Rust: async I/O and io_uring, priority streaming, GPU decompression, sparse virtual textures and cluster streaming. Eleven live widgets and an in-browser streamer.
Asset Pipeline & Serialization
Turning source art into fast-loading runtime data, in C++ and Rust: the offline bake, binary serialization (endianness, alignment, POD), schema versioning and migration, GUIDs vs generational handles, the dependency graph, hot reload, and zero-copy memory-mapped loading. Three live widgets, including a byte-record inspector and an asset-dependency graph.
Data Compression for Games
Compression from entropy up, in C++ and Rust: LZ77 sliding windows, Huffman and ANS entropy coding, DEFLATE, the modern codecs (zstd, LZ4, Brotli), why decode speed not ratio sets load times, Oodle and console hardware decompression, and the separate world of GPU texture compression. Three live widgets.
Rendering: the 2D path (Vulkan)
The GPU & the Graphics Pipeline
How triangles become pixels, the mental model before any Vulkan: GPU throughput and SIMT, the logical pipeline, rasterization with edge functions and barycentrics, the 2x2 quad, perspective-correct interpolation, the depth buffer and reversed-Z, early-Z, and immediate-mode vs tile-based GPUs. A software rasterizer in C++ and Rust, three live widgets.
Your First Triangle in Vulkan
The biggest module: a colored triangle in explicit Vulkan, in C++ and Rust (ash). Instance and validation, device and queues, the swapchain, SPIR-V shaders, the baked pipeline, dynamic rendering, command buffers, and the synchronized render loop (semaphores vs fences, frames in flight, swapchain recreation). Three live widgets.
Textures, Samplers & Materials
Texturing in Vulkan, in C++ and Rust (ash): why a texture is a VkImage, the staging upload and its two layout barriers, samplers and filtering, mipmaps and the linear-blit gate, descriptor sets, and the sRGB-vs-linear pipeline plus the double-correction bug. Three live widgets.
The 2D Renderer: Sprite Batching
A 2D sprite renderer in Vulkan, in C++ and Rust (ash): the draw-call problem, the quad and orthographic camera, sprite batching into one draw, instancing, the texture atlas and its bleeding trap, premultiplied vs straight alpha, transparent sorting, and text rendering. Three live widgets.
Audio
The Audio Engine
A game audio engine from scratch, in C++ and Rust: the hard-real-time callback and what it must never do, the lock-free ring to the audio thread, PCM and mixing with headroom, resampling and aliasing, and spatial audio (equal-power panning, distance attenuation, Doppler, HRTF). Three live widgets.
Audio DSP & the FFT
Audio signal processing, in C++ and Rust: the DFT and the FFT, windowing and spectral leakage, the STFT and spectrogram, digital filters (FIR, IIR, the biquad and RBJ coefficients), and convolution reverb. Three live widgets.
A complete 2D game
Rendering: into 3D
Going 3D: Perspective, Depth & Meshes
From the 2D renderer to a real 3D mesh, in C++ and Rust: the perspective projection and its Vulkan deltas, the camera and MVP, wiring the depth buffer into dynamic rendering, the pos/normal/uv vertex, loading glTF meshes, per-object data and std140, the Y-flip winding gotcha, and the scene-graph hierarchy. Three live widgets.
PBR Materials & Lighting
Physically based rendering the way glTF and real engines ship it: the microfacet Cook-Torrance BRDF (GGX, Smith, Schlick-Fresnel), energy conservation, the metallic-roughness texture set and color spaces, normal mapping, punctual lights, HDR tone mapping, and an image-based-lighting overview. A GLSL shader core and three live widgets.
Shadow Mapping
Shadows in Vulkan, in C++ and Rust: the two-pass algorithm, the light view-projection, the depth-only pass, the Vulkan depth-remap gotcha, the bias problem (shadow acne vs peter-panning), PCF, cascaded shadow maps, and omnidirectional shadows. Three live widgets.
Deferred Rendering & the G-buffer
Deferred rendering in Vulkan, in C++ and Rust: the G-buffer and the geometry/lighting split, position from depth, octahedral normals, MRT in dynamic rendering, the full-screen lighting pass, the bandwidth/MSAA/transparency costs, and tiled vs clustered light culling with Forward+. Three live widgets.
Ambient Occlusion & Global Illumination
AO and a GI survey, in C++ and Rust: what AO is and is not, a buildable SSAO over the deferred G-buffer (hemisphere kernel, range check, bias, noise, blur), applying AO to the ambient term only, HBAO/GTAO, and the GI families (baked, probes, DDGI, voxel, SSGI, ray-traced). Three live widgets.
Post-Processing & Anti-Aliasing
The final image-quality pass, in C++ and Rust (Vulkan): the post chain, bloom (a downsample/upsample pyramid with an optional bright-pass), exposure and auto-exposure, color grading, and the anti-aliasing families (MSAA, FXAA, SMAA, TAA, and temporal upscaling). Three live widgets.
Animation
Vertex Animation Textures
Bake a simulation into textures and replay it on thousands of mesh instances from a vertex shader. Soft-body, rigid-body, fluid and sprite modes, precision and encoding, frame blending, and a live in-browser playground.
Skeletal Animation & Skinning
Skeletal animation in C++ and Rust (Vulkan/GLSL): the skeleton and inverse bind matrix, the skinning matrix and vertex weights, linear-blend vs dual-quaternion skinning, animation clips with quaternion slerp, blending, the GPU matrix palette, glTF skins, and an IK overview. Three live widgets.
Animation: Blending, State Machines & IK
Advanced character animation, in C++ and Rust: animation state machines, 1D and 2D blend spaces (gradient-band weights), layered and additive animation, motion matching, and inverse kinematics in depth (FABRIK, CCD, foot IK, look-at). Three live widgets.
Simulation
Physics Simulation
Rigid-body dynamics from integration to constraint solving. Semi-implicit Euler, GJK and SAT collision detection, sequential impulses, warm starting, CCD. Five live widgets including a three-panel integrator comparison, a GJK simplex stepper, and a stacking solver with an iteration-count slider.
Spatial Partitioning
Grids, quadtrees, octrees, BSP trees, BVHs, spatial hashing, and sweep and prune. The acceleration structures behind broad-phase collision, frustum culling, raycasting, and nearest-neighbor queries. Six live widgets, including a ray-BVH traversal animator and a sweep-and-prune demo that measures its own insertion-sort exchanges and shows them go quadratic the moment temporal coherence breaks. Bullet, Unreal, PhysX, Jolt, Nanite, and RTX two-level structures.
Gameplay
Entity Component System
A widely adopted alternative to deep OOP hierarchies in game engines. Sparse sets, archetypes, cache-coherent iteration, structural changes, query matching, generational indices, and system scheduling. Seven live widgets, including a command-buffer replay where the immediate structural change silently skips entities the query matched, and an editable scheduler that rebuilds the conflict graph and repacks the worker lanes on every edit. Overwatch, Unity DOTS, Bevy, Flecs, EnTT and Mass Entity, with the controlled archetype-vs-sparse-set benchmark.
The Gameplay Layer
The gameplay foundation layer, in C++ and Rust (with Lua): the game object model, composition over deep inheritance, the three live models (Unity, Unreal, ECS), component communication (observer and event queue), object lifetime (deferred destruction, generational handles), data-driven design, and embedded scripting. Three live widgets.
AI
Graph Traversal
BFS, DFS, Dijkstra, A*, topological sort, Tarjan's SCC, JPS, and HPA*. The traversal family behind render graphs, navmesh queries, asset cookers and AI. Seven live widgets, including a side-by-side BFS vs DFS maze race and a Dijkstra-vs-A* heuristic slider that visibly breaks optimality past weight 1.
Behavior Trees
The AI decision structure that displaced hand-built FSMs at many AAA studios. Sequences, selectors, decorators, parallel nodes, blackboards, and the part that is actually hard: interruption. Six live widgets, including an abort playground running a real multi-tick evaluator where halt() throws away a half-finished move and says so in the log, and where a memory composite with Observer Aborts set to None visibly fails to react at all.
SMITSIMAX
Simultaneous-move Monte Carlo tree search from first principles. Standard MCTS, the simultaneous-move problem, decoupled trees, UCB1 selection, information sets, Nash equilibrium convergence, regret matching, and a live playground where you play Rock-Paper-Scissors against a Smitsimax agent and watch three selection policies race toward equilibrium.
Game AI: Navmesh & Steering
Navigation meshes and steering for game AI, in C++ and Rust: the navmesh and its dual graph, the Recast generation pipeline, the funnel/string-pulling algorithm, steering behaviors (seek, arrive, wander), flocking, and local avoidance (VO, RVO, ORCA) plus crowds. Three live widgets.
Networking
Tooling
Debugging C++ in Release Mode from Scratch
The bug your QA filed is in the optimized binary, not the debug build. Reading optimized assembly when source is missing, hardware watchpoints, AddressSanitizer's shadow memory, crash-dump triage, race detection. Six live widgets and an end-to-end playbook for the binary the player runs.
Engine Tooling: Dev UI & Profiling
In-engine tooling, in C++ and Rust: immediate-mode vs retained-mode GUI (Dear ImGui / egui), debug panels, CPU profiling (sampling vs instrumentation, the flame chart), GPU profiling (timestamp queries, frame capture), the CPU-bound vs GPU-bound diagnosis, and hot reload. Three live widgets.
A small 3D game
Extensions beyond the capstone
Open-World Streaming
The world-cell layer above File Streaming: partition the world into cells, load a window of them around the player, and keep the frame smooth. Stutter in these systems more often comes from main-thread work than from disk throughput, and the widgets show where. Three live widgets, C++ and Rust.
Save Games & Serialization
Persisting mutable world state: why you cannot write a pointer to disk (and the handle fix-up that does work), save versioning and migration so old saves still load after a patch, and the atomic write that survives a crash mid-save. Three live widgets, C++ and Rust.
Off the critical path
Standalone pages outside the Build a Game Engine curriculum, readable in any order.
Outside reading on reverse engineering, rendering, networking, concurrency, and C++, plus the occasional cursed one-liner. Links go to the original source, newest first.
kciter.so
Railway-Oriented Programming
Scott Wlaschin's error-handling model, worked through in Kotlin. Functors and monads, the two-track railway, constraining error types. It carries over to any language with sum types.
themaister.net
Ridiculously Fast Game Streaming Video Codec: PyroWave
A game-streaming codec built for latency, not ratio. Intra-only, fixed bitrate, B-frames and flexible rate control thrown out to hit the ~20ms budget. Wavelet-based and GPU-friendly.
iretq.com
How Forza Horizon 6 Breaks Your IDA
Forza Horizon 6 hangs IDA at startup. The game blocks the reverse-engineering tool on a wait for a named object; the author traces it through the stuck call stack.
PivCo-Huffman
A Huffman variant built on a wavelet-tree structure. SIMD-friendly encode and decode that beats state-of-the-art decoders on throughput, with ANS on skewed nodes to close the ratio gap.
Data Access Patterns That Make Your CPU Really Angry
The slowest way to sum an array. An access pattern built to run over 30% slower than random access by working the TLB and cache against you.
icode4.coffee
HDD Firmware Hacking, Part 1
Dumping, reversing, and modifying hard-drive firmware. JTAG debugging a live drive and identifying an unknown MCU, begun in service of an Xbox 360 exploit.
jkm.dev
How 2004 RuneScape fit a multiplayer RPG into 56k dial-up
Every byte of a single movement step traced across the wire, from a decompiled 2004 client. A sustained exercise in not wasting bytes on 5KB/s.
Write your own Neural Network!
Nielsen's free book. Perceptrons through backpropagation, a digit classifier built by hand, the four fundamental equations, and why the deep versions work.
Language Models are Unsupervised Multitask Learners
The GPT-2 paper. Scale an autoregressive transformer on WebText and zero-shot task transfer falls out without task-specific training.
TinyStories: How Small Can Language Models Be and Still Speak Coherent English?
How small can a language model be and still write coherent English? A synthetic dataset of toddler-vocabulary stories, and sub-10M-parameter models that stay fluent on it.
Attention Is All You Need
The Transformer paper. Drops recurrence and convolution for attention alone, parallelizes training, and sets new WMT 2014 translation scores.
s4dbrd.github.io
How Kernel Anti-Cheats Work: A Deep Dive into Modern Game Protection
BattlEye, Vanguard, and the kernel callbacks they register. Ring-0 memory scanning, why Vanguard loads before boot, and how PCIe DMA hardware reads memory without going through the OS.
The issue of anti-cheat on Linux
Why competitive games refuse to launch under Proton. EAC, BattlEye, and RICOCHET against the trust problem an open kernel creates for anti-cheat.
Near complete hypervisor, driver, and system binary analysis for the Xbox Series consoles
Static and dynamic teardown of the Xbox Series S internals through the official developer mode. Hypervisor, drivers, and system binaries, no exploits used.
atredis.com
General Graboids: Worms and Remote Code Execution in Command & Conquer
Remote code execution and a self-propagating worm in the open-sourced Command & Conquer: Generals. Network architecture, attack surface, and a working proof of concept.
Explore the C++ standard as a text adventure game
Navigate the C++ standard like a text adventure. Commands like go north and timeshift cpp20 move you between sections and standard revisions.
secure.runescape.com
Spudworks: DDoS Protection & Security in RuneScape
Jagex's infrastructure team on the hyper-volumetric DDoS attacks that took RuneScape offline, and the response: more scrubbing capacity, more transit, and more backend headroom.
easings.net
Easing functions
The easing cheat sheet. Every standard curve plotted and named, with the CSS and the math.
mas-bandwidth.com
XDP for Game Programmers
Glenn Fiedler on kernel-bypass networking. XDP and eBPF to push past 10gbps once per-packet kernel overhead becomes the wall.
Fix Your Timestep
Glenn Fiedler's classic. Fixed versus variable delta time, the accumulator, and why you interpolate the render state. The reference answer for stepping physics.
momo5502.com
Reverse Engineering Denuvo in Hogwarts Legacy
A Navaja Negra 2025 talk on Denuvo Anti-Tamper internals: protection mechanisms, obfuscation, and how it fuses into the executable. Slides and the Sogen emulator included.
deadlockempire.github.io
Deadlock Empire - Slay dragons, master concurrency!
Play the scheduler. Exploit flawed concurrent programs to break them, learning races and deadlocks by deliberately causing them. Browser game.
silentsblog.com
How a 20 year old bug in GTA San Andreas surfaced in Windows 11 24H2
The seaplane vanished on Windows 11 24H2. A two-decade-old undefined-behaviour bug that only surfaced when the OS shifted the stack layout under it.
Lockless Programming Considerations for Xbox 360 and Microsoft Windows
Microsoft's canonical writeup. Why lockless is subtle on Xbox 360 and Windows, where the barriers go, and when to just share data less often instead.
xairy.io
Unlocking secret ThinkPad functionality for emulating USB devices
Turning a ThinkPad into a programmable USB device by enabling a hidden xDCI controller. A journey through kernel drivers, xHCI, ACPI, BIOS, NVRAM, and a custom cable.
screeps.com
MMO sandbox game for programmers
An MMO where you script your units in real JavaScript. They gather, build, and fight on a persistent server while you are offline.
icode4.coffee
Hacking the Xbox 360 Hypervisor, Part 2: The Bad Update Exploit
Finding and exploiting the bugs behind the Bad Update exploit for full code execution. Follows the part 1 system overview.
icode4.coffee
Hacking the Xbox 360 Hypervisor, Part 1: System Overview
The architecture and hardware security features that kept the Xbox 360 free of a software-only hack for nearly 20 years. Prerequisite reading for the exploit in part 2.
Command & Conquer Remastered Collection
EA's public source for TiberianDawn.dll, RedAlert.dll, and the map editor. Steam Workshop support, buildable in Visual Studio.
The MMORPG for code lovers
An MMORPG played entirely through an API. Write code to move, craft, fight, and gather. Built for people who would rather script than click.
lia.mg
Despair-Driven Development: Harnessing Malaise for Effective Software Engineering
Channelling existential malaise into shipped software. A tongue-in-cheek methodology paper.
danielchasehooper.com
Learn Shader Programming with Rick and Morty
An interactive signed-distance-field tutorial. Rick animated in 240 lines, no images, live-editable in the page. GPU shaders from the ground up.
ssno.cc
Reverse Engineering Call Of Duty Anti-Cheat
Treyarch Anti-Cheat inside Black Ops Cold War. User-mode checks, Arxan obfuscation, and pseudocode of the protection logic, with some details redacted.
Denuvo Analysis
Personal notes on recent Denuvo iterations. Semi-online DRM, integrity checks on both code and license, and techniques not previously shared publicly.
What every systems programmer should know about concurrency
Bit-bashing's concurrency primer. Memory ordering, atomics, and barriers, plus the hardware reality sitting under the abstractions. PDF.
pikuma.com
How PlayStation Graphics & Visual Artefacts Work
How the PS1 renders 3D and why it warps. Affine texture mapping, no depth buffer, and vertex snapping, explained from the hardware limits that cause them.
How to make a game console from scratch
An oscilloscope-drawn games console built in 2014. Twelve thousand lines of hand assembly, physical cartridges, and a hand-built enclosure.
Mario Gameplay Implementation Details
Reimplementing Mario's run and jump feel in assembly. Why the jump arc is so easy to get wrong, and what it took to make it right. Playable in-browser.
security.googleblog.com
Safer with Google: Advancing Memory Safety
Google's strategy for the roughly 70% of severe vulnerabilities in memory-unsafe codebases that are memory-safety bugs: migrate to memory-safe languages and harden the C++ that remains.
Argument Dependent Lookup in C++
Argument-dependent lookup in C++, laid out visually. How an unqualified call finds functions in the argument's namespace, and when qualification shuts ADL off.
Zig and Rust
Seven years of Rust, then a switch to Zig full-time. Not a balanced comparison; a take on reliability, allocation-conscious style, and what Zig buys.
media.ccc.de
Non-Euclidean Doom: what happens to a game when pi is not 3.14159
What happens to Doom when pi is wrong. Breaking the trig constants in the source and walking the warped world that results. MCH2022 talk.
voidstarsec.com
Hardware Hacking with a Raspberry Pi
Part 1 of a series on using a Raspberry Pi as a hardware-hacking multitool: setting up the Pi as a debug and firmware-extraction rig. The target teardown comes in part 2.
wheybags.com
Resurrecting a dead Dune RTS game
EmperorLauncher patches Emperor: Battle for Dune to run on modern systems: high resolution, working online multiplayer, coop campaign.
memorycorruption.net
Lua exploit in Factorio
Arbitrary client execution from a malicious server through Factorio's Lua. The exploit corrupts memory at the bytecode level of the game's embedded Lua VM.
staniks.github.io
Serious Sam Networking Analysis
Reading the Serious Engine 1 source for its netcode. Float determinism, tick versus frame, the packet and message layers, reliability, and sessions.
ripitapart.com
Dispo Adventures, Episode 1: Reverse-engineering and “running Windows 95” on a disposable vape.
Reverse-engineering disposable vapes with colour LCDs and skinning them with a Windows 95 theme. Custom tools and documentation are on GitHub.
ruby0x1.github.io
Writing a Low-Level Sound System
Writing your own audio mixer: sampling, mixing, and gain ramping, with no FMOD or Wwise. From Our Machinery, on owning the whole stack.
dsxm.de
Hiding between opcode bytes - GUloader-like string obfuscation in Rust
GULoader-style string obfuscation ported to Rust. A function that reads its own saved return address, decrypts the bytes embedded below it, and rewrites the address to skip them.
The association for computational heresy
The SIGBOVIK 2024 proceedings. Joke academic papers pushed to absurd but technically rigorous ends.
Software optimization resources
Agner Fog's optimization manuals. Instruction timings, microarchitecture details, and calling conventions for Intel, AMD, and VIA. The x86 reference, and not for beginners.
redblobgames.com
Introduction to the A* Algorithm
Red Blob's interactive pathfinding tutorial. Breadth-first, Dijkstra, and A* built up with draggable demos. The canonical place to start.
netflixtechblog.com
Seeing through hardware counters: a journey to threefold performance increase
A Netflix Java service that failed to scale on bigger instances, traced with hardware performance counters to false sharing, then true sharing, on a JVM-internal cache. A threefold throughput gain.
bclarkson-code.com
Building an LLM from scratch
Scalar autograd first. A tech-tree approach to a full language model, starting by differentiating arbitrary functions in vanilla Python.
shopify.engineering
Refactoring Legacy Code with the Strangler Fig Pattern
Shopify shrinking a 3000-line Shop model. Incrementally routing around legacy code until the old path can be cut.
openai.com
Video generation models as world simulators
The Sora technical report. A diffusion transformer over spacetime patches, and the claim that scaling video generation is a path to general world simulators.
faultlore.com
Text Rendering Hates You
Why no system renders text perfectly. Subpixel positioning, hinting, selection, and wrapping, where everything affects everything else. From years on Firefox rendering.
Understanding C++ Modules
The in-depth series on C++ modules. Module units, export and import, reachability, and linkage. What modules are, and what they can and cannot do.
c0de517e.blogspot.com
A retrospective of Call of Duty Rendering
Recapping the research published on past Call of Duty titles, including how a 60hz shooter shipped on PS3 and the tricks that made it fit. From inside Activision.
2023 Advances in Realtime Rendering slides
The SIGGRAPH 2023 course index. Slides from every talk in the course, which covers the year's shipped and near-shipping rendering techniques.
drive.google.com
Picking a Good Spot: Naughty Dog’s Post System
Naughty Dog's system for picking cover and firing positions. How NPCs choose a good spot to stand and shoot from.
The C++20 Naughty and Nice List for Game Devs
Which C++20 features to reach for and which to avoid, from a 10M+ line codebase with heavy DLL use and hard limits on binary size.
algs4.cs.princeton.edu
Computer Science BookSites
Sedgewick and Wayne's companion sites for Algorithms, 4th ed and the analysis-of-algorithms books. Code, exercises, references, and lectures.
gpuopen.com
How do I become a graphics programmer? - A small guide from the AMD Game Engineering team
AMD's Game Engineering team on the first steps into graphics programming, plus a list of the sites worth reading to get there.
In-depth analysis on Valorant’s Guarded Regions
How Vanguard hides memory from bad actors with shadow regions. The mechanism is simple; the analysis shows why it is hard to get around.
Nifty Fold Expression Tricks
Abusing C++17 fold expressions and operator evaluation order to replace recursive variadic templates with single expressions. Unreadable, but fast to compile.
Jedi: Fallen Order – Splishy Splashy
The splash effects in Jedi: Fallen Order are 95% mesh particles, not textures. A teardown of the water FX with the meshes pulled apart.
shaneycg.github.io
RGBV Texture Compression in DuckTales: Remastered
WayForward's texture compression for DuckTales: Remastered. Why DXT artifacts land badly on their art style, and the scheme they built to avoid it.
acko.net
Teardown of a frame
A one-frame breakdown of Teardown's voxel engine. How a fully destructible world renders, with raytraced global illumination and real-time reflections.
Not all dot products are equal
A crash in a sort predicate on one platform only. The cause: under fast-math, the compiler evaluated the same dot product once with FMA and once with separate multiply and add, and the rounding difference broke the comparator's strict weak ordering.
Behind the scenes of Live++ Hot Reload in c++
How Live++ patches running C++ without a restart. A THQ Nordic Dev Summit talk on the mechanics behind hot reload. Slides.
remedygames.com
How Northlight makes Alan Wake 2 shine
A high-level overview of Remedy's engine tech behind Alan Wake 2: a new data-oriented ECS object model, and the rendering work that goes with it.
AddressSanitizer: A Fast Address Sanity Checker
The original AddressSanitizer paper. A shadow-memory scheme for catching use-after-free and out-of-bounds at about 73% average slowdown.
Machine learning for game developers by EA
SEED's C++-first machine-learning intro for game programmers. Part one covers multilayer perceptrons: understanding and building a classic neural net.
dodov.dev
Magical Software Sucks: Throw Errors, Not Assumptions
In PHP, __call runs whenever you invoke a method that doesn't exist. An argument against magic in code, with the failure modes it quietly hides.
agraphicsguynotes.com
Fibers
Fibers for cooperative multitasking in C++, from a graphics programmer. What they are, why they stay underappreciated, and how they fit an engine job system.