Mighty Professional
Gaming
AAA dev gone indie โ long-form, hands-on tutorials on the systems behind games, graphics, and ML.
Tutorials
Build a Game Engine
The whole series as one map. Every system a real engine needs, ordered so each builds on the last, from the cache up to a game you can play. C++ and Rust throughout, Vulkan for the renderer, a 2D engine first and then 3D. An interactive dependency graph shows exactly what to read before what.
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. The lesson that surprises people is where the stutter comes from, almost never the disk. 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.
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. Four 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. Three live widgets, including a clickable bit-field editor and a Kahan-versus-naive summation race.
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.
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.
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.
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.
Capstone: A Small 3D Game
The series finale, in C++ and Rust: assemble every subsystem into a playable 3D survival arena. The master frame loop, the layered AI stack (decide, path, steer, resolve), the deferred render assembly, and a playable in-browser arena, with a full recap of what every module contributed.
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.
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.
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 graph), GPU profiling (timestamp queries, frame capture), the CPU-bound vs GPU-bound diagnosis, and hot reload. Three live widgets.
Networking: Netcode & Rollback
Game netcode in C++ and Rust: why networking is hard, UDP vs TCP, deterministic lockstep, client-side prediction and server reconciliation, entity interpolation, snapshots and delta compression, lag compensation, and rollback netcode (GGPO). Three live widgets.
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.
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.
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.
Post-Processing & Anti-Aliasing
The final image-quality pass, in C++ and Rust (Vulkan): the post chain, bloom (a bright-pass and a downsample/upsample pyramid, not a blur), exposure and auto-exposure, color grading, and the anti-aliasing families (MSAA, FXAA, SMAA, TAA, and temporal upscaling). 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.
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.
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.
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.
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.
Capstone: A Complete 2D Game
The 2D milestone: wire every engine subsystem into a small playable arena shooter, in C++ and Rust. The shape of main(), the frame anatomy (fixed-timestep sim, interpolated render), the game-object model, the audio ring, 2D physics in one accumulator, and a game you can play right in the browser.
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.
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.
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.
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.
SIMD from Scratch
Sixteen XMMs, sixteen YMMs, thirty-two ZMMs and the AVX-512 mask registers. SoA vs AoS, the eight-accumulator trick that lifts a reduction from one FMA per four cycles to two per cycle, pshufb as a parallel lookup table, gather without footguns. Six live widgets, a worked frustum cull at 8 spheres per AVX2 iteration, and a clear-eyed read on the AVX-512 frequency story in 2026.
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.
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 Allocators from Scratch
Every allocator an engine actually ships with: 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.
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.
C++ Containers
Every standard container an engine actually ships with: vector, deque, list, map, unordered_map, the adaptors, the views. Memory pictures, complexity proofs, and a live race that makes the 50ร gap between vector and list visible.
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.
The C++ Memory Model from Scratch
Cache coherence, store buffers, the five orderings, false sharing, ABA, hazard pointers, the ARM-correct Chase-Lev deque. Every step a live demo, every quantitative claim cited.
Vertex Animation Textures
Bake a simulation into pixels, replay it on ten thousand mesh instances from a vertex shader. Soft body, rigid body, fluid, sprite โ encoding, decoding, frame blending, and a live in-browser playground.
Neural Networks from Scratch
Build a working classifier from a single neuron up through backpropagation. No frameworks, no hand-waving. Includes a live in-browser trainer.
File Streaming for Game Engines
Build a working game-engine streamer, the kind that lets Spider-Man cross Manhattan and Nanite render a quarry of statues with no loading screens. Async I/O, GPU decompression, virtual textures, cluster streaming.
Job Systems from Scratch
Build a modern work-stealing scheduler, the kind that runs The Last of Us and Doom Eternal at 60 fps. Live demos, working C++ and Rust code, and an in-browser playground.
Graph Traversal
BFS, DFS, Dijkstra, A*, topological sort, Tarjan's SCC, JPS, and HPA*. The two algorithms behind every render-graph compile, navmesh query, asset cooker, and behavior-tree tick. Six 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.
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.
Hash Tables from Scratch
The O(1) lookup behind entity maps, asset registries, string interning, and shader variant caches. Chaining, linear probing, Robin Hood hashing, Swiss tables with SIMD metadata, deletion strategies, load factor analysis, and five live widgets including a probe-sequence stepper and a clustering visualizer.
Entity Component System
The architecture that replaced deep OOP hierarchies in AAA engines. Sparse sets, archetypes, cache-coherent iteration, structural changes, query matching, generational indices, and system scheduling. Five live widgets including an archetype table visualizer and an OOP-vs-ECS iteration race.
Spatial Partitioning
Grids, quadtrees, octrees, BSP trees, BVHs, and spatial hashing. The acceleration structures behind broad-phase collision, frustum culling, raycasting, and nearest-neighbor queries. Five live widgets including a quadtree builder, a ray-BVH traversal animator, and a dynamic AABB tree.
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.
Behavior Trees
The AI decision structure that replaced hand-crafted FSMs in AAA. Sequences, selectors, decorators, parallel nodes, blackboards, reactive evaluation, and utility scoring. Five live widgets including a tick-by-tick tree visualizer, an FSM-vs-BT scaling demo, and a priority interrupt animator.
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.