A collection of links for various fields of software development (Mostlt Graphics). Mainly game related, most have been read and vetted. If you find any dead links, please submit an issue and I will try to address it as soon as possible.
- Project Management
- Math
- Game Design
- Languages
- AI
- Rendering
- Vulkan
- DX12
- Textures And Compression
- Colors
- Forward, Deferred, Visibility, Etc
- Transparency, Blending
- GPU Architecture
- Code
- Particles
- Shadows
- Spherical Harmonics
- Raytracing
- Blue Noise
- Graphics Codebases
- Normals And Tangent Spaces
- Shaders
- Lighting/Shading
- Ambient Occlusion
- Subsurface Scattering
- Importance Sampling
- Cameras, Exposure, Tonemapping
- Misc
- Occlusion
- Atmosphere/Clouds
- Depth
- Signed Distance Fields
- Tutorials
- Shader Editors
- Floating Point
- Algorithms
- Networking
- CPU Archicture
- Retro
- Threading
- Sound
- Collision
- Misc
- Unity
- Unreal
- How We Ended Up With Microservices (Blog Post)
- Maker's Schedule, Manager's Schedule (Blog Post)
- An epic treatise on scheduling, bug tracking, and triage (Blog Post)
- Characterizing Software Developers by Perceptions of Productivity (Paper)
- When Culture Doesn’t Translate (Blog Post)
- Why Software Projects Take Longer Than You Think (Blog Post)
- Evidence Based Scheduling (Blog Post)
- Programmer Time Translation Table (Blog Post)
- 2015 Chaos Report (Data)
- 17 theses software estimation (Blog Post)
- Fourier Transform: A Visualization (Video)
- Waveforms: An Introduction (Article)
- Faster Quaternion-Vector Multiplication (Blog Post)
- A primer on Bezier Curves (Online Book)
- Quaternion Visualization (Resource)
- Thin triangle and other tricks (REVEALED!) (Blog Post)
- Another View on the classic ray-aabb intersection algorithm for BVH traversal
- Visualizing Variance (Blog Post)
- Implementing Needlets (Blog Post)
- Frames, Quadratures and Global Illumination: New Math for Games (Slides)
- Don't Use Moving Averages (Blog Post)
- Extra Creditz (Youtube Channel)
- Designing For Coziness (Article)
- Learning From The Masters: Level Design In The Legend Of Zelda (Article)
- Strict Aliasing (Article)
- Minimalist Containers in C(P1) (Blog post)
- Minimalist Containers in C(P2) (Blog post)
- BitHacks (Collection?)
- Coroutines in less than 20 lines of standard C (Blog Post)
- Coroutines in C (Blog Post)
- Demystifying the restrict Keyword (Blog Post)
- Shared Libraries (Blog Post)
- Linkers (Blog Series)
- Fast floating point rand (Blog Post)
- A Whirlwind Tutorial on Creating Really Teensy ELF Executables for Linux (Blog Post)
- Basics of futexes (Blog Post)
- Anybody who writes #pragma pack(1) may as well just wear a sign on their forehead that says “I hate RISC” (Blog Post
- Benchmarking Malloc with Doom 3 (Blog Post)
- Undefined behavior, and the Sledgehammer Principle (Blog Post)
- A bit of background on compilers exploiting signed overflow (Blog Post)
- C Isn't A Programming Language Anymore (Blog Post)
- How can a program survive a corrupted stack? (Blog Post)
- To Save C, We Must Save ABI (Blog Post)
- The Purpose of memory_order_consume in C++11 (Blog Post)
- Molecular Musings (C++ Blog)
- Perfect Forwarding (Article Series)
- DLL Hot Reloading (Article)
- Thunk and its uses (Article)
- How to avoid C/C++ runtime on Windows (Article)
- Job System Implementation (Article)
- Spin Lock Implementation (Article)
- Mike Acton DoD Workshop
- Handles are the better pointer (Blog Post)
- Efficient Argument Passing in C++11 (Blog Post)
- Peephole Optimizations in C++ and C# (Blog Post)
- Optimizations in C++ compilers (Article)
- References - Simply (Blog Post)
- Linkers (Blog Series)
- Optimizations in C++ Compilers (Blog Post)
- How C++ Resolves A Function Call (Blog Post)
- The Subtle Dangers of Temporaries in for Loops (Blog Post)
- Incrementing Vectors (Blog Post)
- The C++20 Naughty and Nice List for Game Devs (Blog Post)
- Optimizing the unoptimizable: a journey to faster C++ compile times (Blog Post)
- Marshaling in C# (Blog)
- Everyone thinks about garbage collection the wrong way (Blog)
- The stack is an implementation detail (Blog)
- The Truth About Value Types (Blog)
- Debunking another myth about value types (Blog)
- How Generics are implemented in C# (Blog Post)
- Construction Destruction (Blog Post)
- Lock And Exceptions Do Not Mix (Blog Post)
- Atomacity, Volatility and Immutability Are Different (Blog Post)
- Understanding Low Lock Techniques In Multi-threaded Apps (Blog Post)
- How LLVM Optimizes a function (Blog Post)
- Crafting Interpreters (Online Book)
- How To Speed Up The Rust Compiler (Blog Post)
- Async Rust Is A Bad Language (Blog Post)
- Single Renderpass Deferred Shading on Mobile
- Vulkan Subpasses
- Yet another blog explaining Vulkan synchronization
- A Tour Of Granite's Vulkan Backend (Blog Series)
- Vulkan Fast Paths (Slides)
- Using Arrays of Textures in Vulkan (Blog Post)
- Vulkan Textures Unbound (Blog Post)
- Binding Bindlessly (Blog Post)
- Render Target APIs (Blog Post)
- Writting An Efficient Vulkan Renderer (Blog Post/Article)
- The Missing Guide to Modern Graphics APIs – 2. PSOs (Blog Post)
- Graphics API secrets: format casting (Blog Post)
- VK_EXT_descriptor_buffer (Blog Post)
- Descriptors are hard (Blog Post)
- Improving shader performance with Vulkan’s specialization constants (Blog Post)
- Hardcore Vulkan debugging – Digging deep on Linux + AMDGPU (Blog Post)
- Writing an efficient Vulkan renderer (Blog Post)
- Shader Assembly and D3D12 Root Signatures (Blog Post)
- GPU Memory Pools in D3D12 (Blog Post)
- Arkham Quixote (Blog Post)
- Managing Memory for Acceleration Structures in DirectX Raytracing (Blog Post)
- Tips: Acceleration Structure Compaction (Blog Post)
- Advanced Graphics moving to DirectX 12 (GDC slides)
- In-Game GPU Profiling for DirectX 12 Using SetBackgroundProcessingMode (Blog Post)
- Tier 2 Variable Rate Shading in Gears (Video)
- Work Graphs in Direct3D 12: A Case Study of Deferred Shading (Blog Post)
- Copy Queue Woes (Blog Post)
- Understanding BCn Texture Compression Formats (Blog Post)
- Compressed GPU Texture Formats - A Review And Comute Shader Decoders Part 1 (Blog Post)
- Bindless Texturing for Deferred texturing and Decals (Blog Post)
- Compressing PBR texture sets with sparsity and dictionary learning (Blog Post)
- Texture Compression In 2020 (Blog Post)
- GPU BCn Decoding (Blog Post)
- Texture Tiling And Swizzling (Blog Post)
- Lossless Image Compression in O(n) Time (Blog Post)
- An Introduction To BCn Texture Compression, Part 1: BC4 (Blog Post)
- A perceptual color space for image processing (Blog Post)
- How the CIE 1931 RGB Color Matching Functions Were Developed (Blog Post)
- RGBM Color Encoding (Blog Post)
- The Hitchikers Guide To Digital Color (Website)
- Color Enhancement And Rendering In Film And Game Production (Slides)
- The Apparent Simplicity of RGB Rendering (Blog Post)
- On Light, Colors, Mixing Paints, and Numerical Optimization. (Blog Post)
- How video games use LUTs and how you can too (Blog Post)
- Forward+ Decal Rendering (Blog Post)
- Visibility Buffer Rendering With Material Graphs (Blog Post)
- The Visibility Buffer: A Cache-Friendly Approach to Deferred Shading (Paper)
- A Primer On Efficient Rendering Algorithms & Clustered Shading. (Blog Post)
- Non-interleaved Deferred Shading of Interleaved Sample Patterns (Paper)
- Adventures with Deferred Texturing in Horizon Forbidden West (Blog Post)
- WBOIT in OpenGL: transparency without sorting (Blog Post)
- Order Independent Transparency (Slides)
- Alpha Blending: To Pre or Not To Pre (Blog Post)
- Alpha Compositing (Blog Post)
- Premultiplied Alpha (Blog Post)
- Order independent transparency, part 1 (Blog Post)
- Moment-Based Order-Independent Transparency (Paper)
- Channeling Alpha (Blog Post)
- A Trip Through the Graphics Pipeline (Blog Series)
- Understanding GPU Context Rolls (Article)
- Revisiting the Vertex Cache (Article)
- Zero Driver Overhead (GDC Talk)
- GPU Barriers (Blog Post)
- Tile Based Renderers
- Register Spilling
- GPU Resources (Twitter Thread)
- GPU Architecture Resources (Blog Post)
- GPU Memory Aliasing (Blog Post)
- Rasterization Rules (MSDN)
- Overdraw in Overdrive (Blog Post)
- Counting Quads (Blog Post)
- How bad are small triangles on GPU and why? (Blog Post)
- Understanding Modern GPUs - Part 1 (Blog Post)
- GPU Processing Budget Approach To Game Development (Blog Post)
- The Mali GPU An Abstract Machine - Part 3 (Blog Post)
- What is shader occupancy and why do we care about it? (Blog Post)
- What's up with my branch on GPU? (Blog Post)
- Intro To GPU Scalarization - Part 1 (Blog Post)
- Analysis Driven Optimization: Preparing for analysis with NVidia Nsight Compute (Blog Series)
- The AMD GCN Architecture - A Crash Course (Slides)
- Gentle Introduction To GPU Inner Workings (Blog Post)
- Advanced Shader Programming On GCN (Slides)
- GPU Architectures Explained (Blog Post)
- Triangle Setup And Rasterization For FGPA (Blog Post)
- Linear-Speed Vertex Cache Optimisation (Paper)
- RDNA3 ISA (Paper)
- RDNA Architecture (Paper)
- Fine-grained backface culling (Blog Post)
- GPU Hang Exploration: Splitgate (Blog Post)
- Explore GPU advancements in M3 and A17 Pro (Video)
- Occupancy explained (Blog Post)
- Examining AMD’s RDNA 4 Changes in LLVM (Blog Post)
- Conformant OpenGL 4.6 on the M1 (Blog Post)
- Understanding Memory Coalescing on GCN (Blog Post)
- Variance Shadow Maps (Paper)
- A Sampling of Shadow Techniques (Blog Post)
- Raytraced Shadows in Call of Duty Modern Warfare (Slides)
- Combining Analytic Direct Illumination and Stochastic Shadows (Paper)
- Experiments in Hybrid Raytraced Shadows (Blog Post)
- Shadow Techniques from Final Fantasy XVI (Blog Post)
- Spherical Harmonic Gradients for Mid-Range Illumination (Paper)
- Spherical Harmonic Irradiance Gradients (Slides)
- Stupid Spherical Harmonic Tricks (Paper)
- Spherical Harmonic Lighting: The Gritty Details (Paper)
- Spherical Harmonics - Patapom (Blog Post)
- Alternative definition of Spherical Harmonics for Lighting (Blog Post)
- Converting SH Radiance to Irradiance (Blog Post)
- Ray Tracing Denoising (Blog Post)
- Raytracing Reflection, Refraction, Fresnel, Total Internal Reflection, and Beer's Law (Blog Post)
- Ray Tracing In A Weekend (Book)
- Ray Tracing The Rest of Your Life (Book)
- Raytracing a tiny procedural planet (Slides)
- Importance Sampling Visible Wavelengths (Blog Post)
- Increasing wave coherence with ray binning (Blog Post)
- Spherical Area Light Sampling (Blog Post)
- Raytracing In Hybrid Real-time Rendering (Slides)
- Real-Time Path Tracing And Beyond (Slides)
- STOCHASTIC ALL THE THINGS: RAYTRACING IN HYBRID REAL-TIME RENDERING
- Adventures in Hybrid Rendering (Blog Post)
- RE: 2023 - Advances in Ray Tracing (Video)
- RE: 2023 - New Rendering Features Rundown, SDFs (Video)
- Ray tracing animated crowds (Blog Post)
- Beyond SAH — Building Optimal BVHs (Blog Post)
- Improving raytracing performance with the Radeon™ Raytracing Analyzer (RRA) (Blog Post)
- Distributing Monte Carlo errors as Blue Noise in Screen Space - Part 1 (Blog Post)
- What the heck is blue noise? (Blog Post)
- Spatio-Temporal Blue Noise (Video)
- Sample Elimination for Generating Poisson Disk Sample Sets (Paper)
- Molecular Matters - Stateless Threaded Rendering Series
- Molecular Matters - DoD Series
- Rendering Abstraction Layers (Blog Post)
- How (not) to test graphics code (Blog Post)
- My toy renderer: Overview (Blog Series)
- Tangent Spaces and Diamond Encoding (Blog Post)
- Improved Normal Reconstruction From Depth (Blog Post)
- Accurate Normal Reconstruction From Depth Buffer (Blog Post)
- Orthonormal Basis (Paper)
- Normals revisited (Blog Post)
- Normal Mapping without Precomputed Tangents (Blog Post)
- Survey of Efficient Representations for Independent Unit Vectors (Paper)
- The Shader Permutations Problem (Blog Series)
- Half The Precision, Twice The Fun: Working With FP16 In HLSL (Blog Post)
- Floating-point in mobile shaders (Blog Post)
- Interlocked min/max on HLSL single precision floats (Blog Post)
- Shader Printf in HLSL and DX12 (Blog Post)
- HLSL Constant Buffer Packing Rules (Blog Post)
- Khronos Releases Maximal Reconvergence and Quad Control Extensions for Vulkan and SPIR-V (Blog Post)
- Re-converging control flow on NVIDIA GPUs - What went wrong, and how we fixed it (Blog Post)
- Intro To Compute Shaders (Blog Post)
- Optimizing the graphics pipeline with compute (Slides)
- Optimizing Compute Shaders for L2 Locality (Blog Post)
- Compute Shader Optimizations for AMD GPUs: Parallel Reduction (Blog Post)
- Stream compaction using wave intrinsics (Blog Post)
- Boosting Application Performance with GPU Memory Prefetching (Blog Post)
- A Trip Through The Graphics Pipeline 2011, Part 10 (Blog Post)
- Geometry Shader - Advanced OpenGL (Blog Post)
- My Take On Shaders - Geometry Shaders (Blog Post)
- Geometry Shader Adventures (Blog Post)
- Geometry Shader Stage (Docs)
- A Trip Through The Graphics Pipeline 2011, Part 12 (Blog Post)
- Tessellation - Catlike Coding (Blog Post)
- Surface Displacement (Blog Post)
- Tesselation Optimizations (Blog Post)
- Tesselation Shaders (Blog Post)
- Advanced Stages - Tessellation (Docs)
- Mesh Shader Possibilities (Blog Post)
- Mesh and task shaders intro and basics (Blog Post)
- How mesh shaders are implemented in an AMD driver (Blog Post)
- Task shader driver implementation on AMD HW (Blog Post)
- Performance Comparison of Meshlet Generation Strategies (Paper)
- Mesh Shaders on RDNA™ Graphics Cards (Blog Post)
- Modernizing Granite’s mesh rendering (Blog Post)
- Optimization and best practices (Blog Post)
- Procedural grass rendering (Blog Post)
- Meshlet triangle locality matters (Blog Post)
- Introduction to Lighting (Blog Post)
- Mathematics of shading (Course Notes)
- Introduction to shading (Tutorial)
- PI or not to PI in game lighting equation (Blog Post)
- PBR Diffuse Lighting for GGX (Slides)
- Physically Based Rendering References At The End of 2019 (Blog Post)
- Google Filament PBR (Code base breakdown)
- Game Environments Parta Remember Me Rendering (Blog Post)
- Moving Frostbite to Physically Based Rendering V3
- Fresnel Equations Schlick Approximations (Blog Post)
- Lights And Shadows (Interactive Blog Post)
- Adventures In Triangle Sampling Part 1 (Blog Post)
- Image Based Lighting With Multiple Scattering
- Adventures in Sampling Points on Triangles - Part 1 (Blog Post)
- Spherical Gaussians Series (Blog Series)
- The Irradiance Volume (Paper)
- Advances In Rendendering, Graphics Research And Video Game Production (Slides)
- Real Shading in Unreal Engine 4 (Paper)
- Discrepancy as a Quality Measure for Sample Distributions (Paper)
- Bias In rendering (Paper)
- Reducing Shading on GPUs using Quad-Fragment Merging (Paper)
- An Area-Preserving Parametrization for Spherical Rectangles (Paper)
- Stable Geometric Specular Antialiasing with Projected-Space NDF Filtering (Paper)
- Moving Frostbite to PBR (PDF)
- Real-Time Polygonal-Light Shading with Linearly Transformed Cosines (Article)
- Light Trees And The Many Lights Problem (Blog Post)
- Light Attenuation (Blog Post)
- Light Attenuation Formula Derivation (Stack Exchange)
- Nonsingular Point Light Attenuation (Video)
- Dynamic Many-Light Sampling for Real-Time Ray Tracing (Paper)
- Importance Sampling of Many Lights with Adaptive Tree Splitting (Paper)
- Geometric Derivation of the Irradiance of Polygonal Lights (Paper)
- Thoughts on light culling: stream compaction vs flat bit arrays (Blog Post)
- A Reflectance Model For Computer Graphics (Paper)
- How is the NDF defined? (Blog Post)
- Sampling Microfacet BRDFs (Blog Post)
- BRDF Definition (Blog Post)
- Fresnel Equations Considered Harmful (Slides)
- BRDF Normalization (Q&A)
- BRDF Normalization (Forum)
- Energy Conservation In Games (Blog Post)
- Energy Conserving Wrapped Diffuse (Blog Post)
- Phong Normalization Derivation (PDF)
- Blinn Phong Normalization Zoo (Blog Post)
- Crash Course In BRDFs (Doc)
- Multiple Scattering BRDF (Blog Post)
- Misunderstanding Multiscattering (Blog Post)
- Microfacet models for refraction through rough surfaces (Paper)
- Average irregularity representation of a rough surface for ray reflection (Paper)
- Sampling Visible GGX Normals with Spherical Caps (Paper)
- A Micrograin BSDF Model for the Rendering of Porous Layers (Paper)
- Screen Space Ambient Occlusion (Doc)
- Screen Space Ambient Occlusion - OGL Dev (Tutorial)
- Screen Space Ambient Occlusion - Learn OpenGL (Tutorial)
- Multiresolution Ambient Occlusion (Blog Post)
- A Taxonomy of Bidirectional Scattering DistributionFunction Lobes for Rendering Engineers (Paper)
- Horizon Split Ambient Occlusion (Paper)
- Efficient Screen-space SSS (Paper)
- Real-Time Subsurface Scattering Intro (Blog Post)
- Approximating Translucency for a Fast, Cheap and Convincing Subsurface Scattering Look (Slides)
- Multiple Importance Sampling Techniques for Monte Carlo Rendering (Paper/Coure Notes)
- Importance Sampling Techniques for GGX with Smith masking-shadowing (Blog Post)
- Importance Sampling Adventure (Tweets)
- Multiple Importance Sampling (Blog Post)
- Can't invert the CDF? Triangle Cut Parametirzation of the Region Under The Curve (Paper)
- Optimally Combining Sampling Techniques for Monte Carlo Rendering (Paper)
- BRDF Importance Sampling for Polygonal Lights (Paper)
- Demystifying multiple importance sampling (Blog Post)
- Rearchitecting Spatiotemporal Resampling for Production (Paper)
- Spatiotemporal reservoir resampling for real-time ray tracing with dynamic direct lighting (Paper)
- ReSTIR GI: Path Resampling for Real-Time Path Tracing (Paper)
- A Gentler Introduction To ReSTIR (Blog Post)
- Dynamic diffuse global illumination (Blog Post)
- Tone Mapping (Blog Post By Bruno Opsenica)
- Tone Mapping (Blog Post By 64)
- Adaptive Exposure from Luminance Histograms (Blog Post)
- Automatic Exposure Using a Luminance Histogram (Blog Post)
- Automatic Exposure (Blog Post)
- Cameras And Lenses (Blog Post)
- Temporal ReprojectionAnti-Aliasing in INSIDE (Slides)
- ISO Sensitivity and Exposure Index (Blog Post)
- Where does 78 come from in exposure calculations? (Forum)
- Exposure Fusion Local Tonemapping For Real-Time Rendering (Blog Post)
- Real-Time Rendering Resources (Holy grail of resources)
- Walt Disney Datasets (Data)
- Aras P - Rendering(Blog)
- Inigo Quilez (Founder of Shadertoy blog)
- The Elusive Frame Timing (GDC Slides)
- Drawing Points Properly in WebGL
- Rendering Graphics Studies (Blog)
- Multi Channel SDF (Codebase)
- Arian Courreges, Game Studies (Blog)
- Advances in realtime rendering(Courses)
- Huge rendering resource repository (Website)
- Fabien Sanglard (Website)
- Shadertoy Discord
- How Unreal Renders A Frame (Blog Post)
- Doom Eternal Graphics Study (Blog Post)
- The Technical Art of The Last of Us Part II (Slides)
- Why are video games graphics (still) a challenge? Productionizing rendering algorithms (Blog Post)
- Computing Gradients On Grids - Forward, Central and diagonal differences (Blog Post)
- Graphics Pipelines For Young Bloods (Blog Post)
- fma: A faster, more accurate instruction (Blog Post)
- Gradients in linear space aren't better (Blog Post)
- Debugging Your Renderer (3/n): Assertions (and on not sweeping things under the rug) (Blog Post)
- Frickin Shaders With Frickin Laser Beams (Shader composition framework) (Blog Post)
- Let’s Close the Buffer Zoo (Blog Post)
- Kajiya GI Overview (Blog Post)
- Slang Shading Language Advances (Slides)
- In defense of NIR (Blog Post)
- Summed Area Tables (Research Paper)
- Material Pipeline for The Order: 1886 (PDF)
- Checkerboard rendering (Blog Post)
- Volumetric Light Effects in Killzone: Shadow Fall (Series)
- Checkerboard Rendering (White Paper)
- Advances in Real-time Rendering 2018 (List)
- A Ray-Box Intersection Algorithm and Efficient Dynamic Voxel Rendering (White Paper)
- Dreams - The tech behind the magic (Video)
- GPU... stuff (Slides)
- Spectral rendering with bounded MESE and sRGB data (Research Paper)
- Distance Fields (Blog Post)
- Text Hates you (Blog Post)
- Digesting The Elephant (Paper)
- Tile Based Optimization for Post Processing (Blog Post)
- Learning From Failure (Blog Post)
- A Pixel Is Not a Little Square (Paper)
- Sampling Reconstruction (Slides)
- Interpolating Data Over Arbitrary Surfaces (Blog Post)
- Smoke Lighting And Texture Re-usability in Skull And Bones (Blog Post)
- Temporal Anti-Aliasing Starter Pack (Blog Post)
- A Gentle Introduction To Fluid Simulation (Blog Post)
- Doom 2016 - The Devil Is In The Details (Slides)
- Notes on occlusion and directionality in image based lighting. (Blog Post)
- Temporal AA and the quest for the Holy Trail (Blog Post)
- Removing blur from images – deconvolution and using optimized simple filters (Blog Post)
- Physical Units for Lights (Blog Post)
- Notes on screenspace reflections with FidelityFX SSSR (Blog Post)
- A mathematical take on Premultiplied alpha (Blog Post)
- Binary Search For SDFs (Blog Post)
- Meshlet Sizing Theory (Blog Post)
- A Blend Of GCN Optimization And Color Processing (Slides)
- Constant Time Stateless Shuffling and Grouping (Blog Post)
- Permutation Coding for Vertex-Blend Attribute Compression (Paper)
- Readers note: Interesting insights on approaches to quantization and storing information through permutations of a sorted list.
- Dynamic Occlusion with Signed Distance Fields (Slides)
- Make Your Game Friendly for Graphics Debugging and Optimization (Slides)
- GPU driven rendering in AnKi: A high level overview (Blog Post)
- Rendering God Of War Ragnarok (Slides)
- Re-inventing The Wheel For Snow Rendering (Slides)
- Hammersley Points on the Hemisphere (Blog Post)
- The Rendering Of The Callisto Protoco (Slides)
- Coverage Bitmasks for Efficient Rendering Algorithms (Slides)
- Radiance Cascades: A Novel Approach to Calculating Global Illumination (Paper)
- Efficient GPU Screen-Space Ray Tracing (Paper)
- Creating a Directed Acyclic Graph from a Mesh (Blog Post)
- Low-level thinking in high-level shading languages 2023 (Blog Post)
- High Performance Voxel Engine: Vertex Pooling (Blog Post)
- Recreating Nanite: LOD generation (Blog Post)
- Occluding Contour Breakthroughs (Blog Post)
- Dead Space Remake - Environmental Shaders (Blog Post)
- Breakdown: Syndicate (2012) (Blog Post)
- ExileCon Dev Talk - Evolving Path of Exile's Renderer (Video)
- Animation Blend Spaces without Triangulation (Blog Post)
- Hash Functions for GPU Rendering (Blog Post)
- About fast 2D CDF construction (Blog Post)
- Rotation with three shears (Blog Post)
- Font and vector art rendering with mesh shaders (Blog Post)
- GPU Programming Primitives for Computer Graphics (Slides)
- Recreating Nanite: Runtime LOD selection (Blog Post)
- Physically Based - Material Parameter Website (Website)
- The Shader graph contract (Blog Post)
- Constant Time Stateless Shuffling and Grouping (Blog Post)
- Filtering After Shading With Stochastic Texture Filtering (Paper)
- Half baked: Dynamic Occlusion Culling (Blog Post)
- Two-Pass Occlusion Culling (Blog Post)
- GPU based occlusion culling (Blog Post)
- Realistic Real-time Sky Dome Rendering in Gran Turismo 7 (Slides)
- Assassin’s Creed 4: Black Flag - Lighting, Weather and Atmospheric Effects (slides)
- Rendering The World Of Far Cry 4 (Slides)
- Physically Based And Scalable Atmospheres In Unreal Engine (Slides)
- A Scalable and Production Ready Sky and Atmosphere Rendering Technique (Paper)
- Schneider VFX Portfolio (Lots of cloud research) (Blog Post)
- Linearize the depth buffer (Forum)
- Maximizing depth buffer range and precision (Blog Post)
- Reversed-Z in OpenGL (Blog Post)
- Love your Z buffer (Blog Post)
- Depth Buffer Interpolation (Blog Post)
- Linear Depth Buffer (Stack Overflow)
- A couple of notes about Z (Blog Post)
- Depth Precision Visualized (Blog Post)
- Depth in-depth (PDF)
- GPU-based clay simulation and ray-tracing tech in Claybook (Slides)
- Ray Tracing of Signed Distance Function Grids (Paper)
- Learn OpenGL (Tutorial)
- Fragment Foundry (Tutorial)
- Intro to compute shaders (Blog Post)
- Scratchapixel (Tutorial)
- PBR Theory (Tutorial)
- FWidth (Tutorial)
- Render graphs and Vulkan — a deep dive (Blog Post)
- An update to our Render Graph - Traverse Research (Blog Post)
- High-level rendering using render graphs (Blog Post)
- Framegraphs extensible render framework in frostbite (Slides)
- Floating Point Error (Blog Post)
- What every computer scientist should know about floating point (Paper)
- There are Only Four Billion Floats so Test Them All (Blog Post)
- Floating Point Determinism (Blog Post)
- Floating Point (White Paper)
- NaNs cause the craziest bugs (Blog Post)
- Visualizing Algorithms (Blog Port)
- Pathfinding with Cellular automota (Blog Post)
- QGrep Internals (Blog Post)
- Branch Prediction Rundown (Blog Post)
- Introduction to dataflow graphs (Blog Post)
- Hardware Effects (Repo)
- Write Combining is not your friend (Blog Post)
- Why do CPUs have multiple cache levels? (Blog Post)
- Assembly Intrinsics (Blog Post)
- Cores don't like to share (Blog Post)
- Modern Microprocessors - A 90-Minute Guide! (Blog Post)
- Memory Disambiguation and Store Forwarding (Blog Post)
- Henry - StuffedCow (Blog)
- Measuring Reorder Buffer Capacity (Blog Post)
- Avoiding Instruction Cache Misses (Blog Post)
- The surprising subtleties of zeroing a register (Blog Post)
- What is the best way to set a register to zero in x86? (Stack Overflow)
- Parallel Computer Architecture And Programming (Lectures)
- Cache Coherence Implementation (Blog Post)
- Notes on non-temporal (aka streaming) stores (Blog Post)
- Cache Coherence Protocols (Blog Post)
- Mutexes Vs Spinlocks (Blog Post)
- The Significance Of The x86 lfence Instruction (Blog Post)
- Why Use LEA instead of ADD (Stack Overflow Answer)
- Using the LEA instruction for arbitrary arithmetic (Blog Post)
- Why x86 Doesn’t Need to Die (Blog Post)
- Decreasing the Number of Memory Accesses (Blog Series)
- Comments on timing short code sections on intel processors (Blog Post)
- Branch/cmove and compiler optimizations (Blog Post)
- It's done in hardware so it's cheap (Blog Post)
- Speed Limits (Blog Post) - Recommended
- Software Optimization Resources (Guides) - Recommended
- SIMD at Insomniac Games (PDF)
- SSE Mind the gaps! (Blog Post)
- AVX-512: When and how to use these new instructions
- By how much does AVX-512 slow down your CPU?
- SMACNI to AVX512 the life cycle of an instruction set (PDF)
- A note on mask registers (Blog Post)
- This Goes To Eleven (Blog Post)
- Old-School Raycasting Pt1 (Series)
- Old-School Raycasting Pt2 (Series)
- Old-School Raycasting Pt3 (Series)
- Old-School Raycasting Pt4 (Series)
- PlayStation 3 Architecture (Blog Post)
- Xbox 360 Architecture (Blog Post)
- Thread Sanitizer A thread debugging tool (Repo)
- Acquire And Release Semantics (Blog Post)
- Acquire And Release Fences Don't Work The Way You'd Expect (Blog Post)
- The Synchronizes With Relation (Blog Post)
- Memory Reordering Caught In The Act (Blog Post)
- Memory Barriers Are Like Source Control (Blog Post)
- Who Ordered Memory Fences On An x86? (Blog Post)
- Are Loads And Stores The Only Instructions That Get Reordered? (Stack Overflow)
- Why Does A std::atomic Store With Sequential Consistency Use xchg (Stack Overflow)
- Does The Intel Memory Model Make sfence and lfence Redundant? (Stack Overflow)
- Why Is A Store Load Barrier Considered Expensive? (Stack Overflow)
- Does Lock xchg Have The Same Behaviour As mfence? (Stack Overflow)
- What is RCU? -- "Read, Copy, Update" (Blog Post)
- A Deep dive into (implicit) Thread Local Storage (Blog Post)
- Condvars and atomics do not mix (Blog Post)
- Simple Intersection Tests For Games (Blog Post)
- 2D AABB vs AABB how to calculate normal (Stack Exchange)
- What's the fastest way of checking if 2 AABB intersect? (Stack Exchange)
- Swept AABB and response (Blog Post)
- Axis-Aligned Bounding Dual Simplex (Google Doc)
- Aras P (Blog)
- Demo Scene and more (Blog)
- Semantic Compression (Blog Post)
- The blog at the bottom of the sea (Blog - Math, Programming, Graphics)
- Digital Signal Processing Guide (PDF Book)
- Why the way we look at technical debt is wrong
- The Story behind The Truth: Designing a Data Model
- A queue of page faults (Blog Post)
- Profiling: Measurement and Analysis (League Of Legends Blog Post)
- Hidden cost of MemoryAllocation (Blog Post)
- A question about avoiding page faults the first time newly-allocated memory is accessed (Blog post)
- AOSOA (Blog Post)
- Over-engineering (the root of all evil)
- How LLVM optimizes power sums (Article)
- Thinking About Technical Debt (Twitter Thread)
- Data Compression - Bit Packing 101 (Blog Post)
- Fibersunder the magnifying glass (Paper)
- Fibers aren’t useful for much any more; there’s just one corner of it that remains useful for a reason unrelated to fibers (Blog Post)
- Write comining is not your friend (Blog Post)
- The Size Of Tracing Data (Blog Post)
- Reading Research: A Guide For Software Engineers (Blog Post)
- Challenges of Debugging Optimized x64 Code (Blog Post)
- Step By Step Programming (Blog Post)
- Insider guide to tech interviews (Blog Post)
- Optimizing astcenc (Blog Post)
- You And Your Research (Blog Post)
- X64 Function Hooking by Example (Blog Post)
- Mike Acton’s Expectations of Professional Software Engineers (Blog Post)
- MAKING TOOLS FOR BIG GAMES (Slides)
- A Matter Of Precision (Blog Post)
- The power of asking why, why, why, why, why (Blog Post)
- Efficient Parallel Prefix Sum in Metal for Apple M1 (Blog Post)
- Systems design 2: What we hope we know (Blog Post)
- The Tyranny of structurelessness(Blog Post)
- How I made Tracy 30× faster (Blog Post)
- Learnings As a Graphics Lead (Blog Post)
- How I Evaluate Game Engines (Blog Post)
- Anti-Debug: Process Memory (Blog Post)
- Recognizing patterns in memory (Blog Post)
- Technical debt… or technical weight/burden? (Blog Post)
- Making a Mesh: Global Mesh Destruction in First Encounters (Blog Post)
- The Grug Brained Developer - A layman's guide to thinking like the self-aware smol brained (Blog Post)
- A dive into the making of Immersion (Blog Post)
- Making floating point numbers smaller (Blog Post)
- How can demoscene productions be so small? (Blog Post)
- OMBRE Dev-Blog Year 1 (Blog Post)
- Speed up your code: don't pass structs bigger than 16 bytes on AMD64 (Blog Post)
- Handle Lookup Container (Sparse Set) (Blog Post)
- Micro-optimizations in Kotlin (Blog Series)
- The Hiring Post (Blog Post)
- No one can teach you to have conviction (Blog Post)
- My favourite Git commit (Blog Post)
- Memory Allocation Strategies (Blog Series)
- Bringing Verse Transactional Memory Semantics to C++ (Blog Post)
- Debugging as a Process of Isolating Assumptions (Blog Post)
- Learning to Debug: Stop Making Assumptions (Blog Post)
- Leaving Rust gamedev after 3 years (Blog Post)
- Readability of Optimized Kotlin Code (Blog Post)
- Reversing Choplifter (Blog Post)
- Lanczos Interpolation Explained (Blog Post)
- What Factors Explain the Nature of Software? (Blog Post)
- Unreal Engine Game Optimization on a Budget (Blog Post)
- Journey To Lumen (Blog Post)
- Journey To Nanite (Slides)
- Nanite Overview (Slides)
- Debugging and Optimizing Memory (Blog Post)
- Distance Field Ray Tracing Part 1: Volume Textures and Ray Marching Primer (Blog Post)
- Unreal Engine 4 Rendering (Blog Series)
- Lumen, Real-time Global Illumination in Unreal Engine 5 (Slides)
- Unreal Engine Substrate: Authoring Materials That Matter (Slides)
- Render Dependency Graph (Documentation)
- Optimizing Shaders in Unreal Engine (Blog Post)
- RDG 101 (Slides)
- Take a deep dive into Nanite GPU-driven materials (Slides)