software-development-resources
What?
A collection of links for various fields of software development. 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.
Table Of Contents
- Project Management
- Math
- Game Design
- Languages
- AI
- Rendering
- Floating Point
- Algorithms
- Networking
- CPUs
- Retro
- Threading
- Sound
- Collision
- Misc
- Unity
- Unreal
Project Management
- 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)
Estimation
- 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)
Math
- 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)
Game Design
- Extra Creditz (Youtube Channel)
- Designing For Coziness (Article)
- Learning From The Masters: Level Design In The Legend Of Zelda (Article)
Languages
C
- 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)
C plus plus
- 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)
C Sharp
- 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)
Misc
- How LLVM Optimizes a function (Blog Post)
- Crafting Interpreters (Online Book)
- How To Speed Up The Rust Compiler (Blog Post)
AI
Rendering
Vulkan and DX12
- Single Renderpass Deferred Shading on Mobile
- Vulkan Subpasses
- Yet another blog explaining Vulkan synchronization
- A Tour Of Granite's Vulkan Backend (Blog Series)
- Render graphs and Vulkan a deep dive (Blog Post)
- 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)
- Shader Assembly and D3D12 Root Signatures (Blog Post)
- GPU Memory Pools in D3D12 (Blog Post)
- Graphics API secrets: format casting (Blog Post)
- VK_EXT_descriptor_buffer (Blog Post)
- Descriptors are hard (Blog Post)
Textures
- 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)
Compute Shaders
- Intro To Compute Shaders (Blog Post)
- Optimizing the graphics pipeline with compute (Slides)
- Optimizing Compute Shaders for L2 Locality (Blog Post)
Colors
- 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)
Forward, Deferred, Visibility, Etc
- Forward+ Decal Rendering (Blog Post)
- A Primer On Efficient Rendering Algorithms & Clustered Shading. (Blog Post)
- Visibility Buffer Rendering With Material Graphs (Blog Post)
- The Visibility Buffer: A Cache-Friendly Approach to Deferred Shading (Paper)
- Visibility Buffer Rendering Approaches and Benefits (Blog Series)
- A Primer On Efficient Rendering Algorithms & Clustered Shading. (Blog Post)
Transparency, Blending
- 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)
GPU
- 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)
- Half The Precision, Twice The Fun: Working With FP16 In HLSL (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 BCn Decoding (Blog Post)
- GPU Architectures Explained (Blog Post)
- The Shader Permutations Problem (Blog Series)
- Floating-point in mobile shaders (Blog Post)
- Triangle Setup And Rasterization For FGPA (Blog Post)
- Compute Shader Optimizations for AMD GPUs: Parallel Reduction (Blog Post)
- Boosting Application Performance with GPU Memory Prefetching (Blog Post)
- Linear-Speed Vertex Cache Optimisation (Paper)
- Stream compaction using wave intrinsics (Blog Post)
- RDNA3 ISA (Paper)
- RDNA Architecture (Paper)
Code
Particles
Shadows
- 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)
Spherical Harmonics
- 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)
Raytracing
- 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)
Blue Noise
- Distributing Monte Carlo errors as Blue Noise in Screen Space - Part 1 (Blog Post)
- What the heck is blue noise? (Blog Post)
Concepts
- Summed Area Tables (Research Paper)
- Material Pipeline for The Order: 1886 (PDF)
- Checkerboard rendering (Blog Post)
- GPU based occlusion culling (Blog Post)
- Molecular Matters - Stateless Threaded Rendering Series
- Molecular Matters - DoD Series
- Volumetric Light Effects in Killzone: Shadow Fall (Series)
- STOCHASTIC ALL THE THINGS: RAYTRACING IN HYBRID REAL-TIME RENDERING
- Checkerboard Rendering (White Paper)
- Normal Mapping without Precomputed Tangents (Blog Post)
- Real-Time Polygonal-Light Shading with Linearly Transformed Cosines (Article)
- 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)
- High-level rendering using render graphs (Blog Post)
- Advanced Graphics moving to DirectX 12 (GDC slides)
- Framegraphs extensible render framework in frostbite (Slides)
- GPU... stuff (Slides)
- Spectral rendering with bounded MESE and sRGB data (Research Paper)
- How (not) to test graphics code (Blog Post)
- Distance Fields (Blog Post)
- Normals revisited (Blog Post)
- Text Hates you (Blog Post)
- Rendering Abstraction Layers (Blog Post)
- Digesting The Elephant (Paper)
- Tile Based Optimization for Post Processing (Blog Post)
- Learning From Failure (Blog Post)
- Orthonormal Basis (Paper)
- 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)
- Improved Normal Reconstruction From Depth (Blog Post)
- Accurate Normal Reconstruction From Depth Buffer (Blog Post)
- Temporal Anti-Aliasing Starter Pack (Blog Post)
- Nanite Overview (Slides)
- A Gentle Introduction To Fluid Simulation (Blog Post)
- My toy renderer: Overview (Blog Series)
- 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)
- Exposure Fusion Local Tonemapping For Real-Time Rendering (Blog Post)
- Removing blur from images – deconvolution and using optimized simple filters (Blog Post)
- Physical Units for Lights (Blog Post)
- Journey To Lumen (Blog Post)
- Journey To Nanite (Slides)
- Notes on screenspace reflections with FidelityFX SSSR (Blog Post)
- A mathematical take on Premultiplied alpha (Blog Post)
- Binary Search For SDFs (Blog Post)
- Two-Pass Occlusion Culling (Blog Post)
- Meshlet Sizing Theory (Blog Post)
- Spatio-Temporal Blue Noise (Video)
- A Blend Of GCN Optimization And Color Processing (Slides)
- Texture Tiling And Swizzling (Blog Post)
- Multiresolution Ambient Occlusion (Blog Post)
- Assassin’s Creed 4: Black Flag - Lighting, Weather and Atmospheric Effects (slides)
- Rendering The World Of Far Cry 4 (Slides)
Geometry Shaders
- 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)
Tesselation Shaders
- 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)
Shading
- How is the NDF defined? (Blog Post)
- Sampling Microfacet BRDFs (Blog Post)
- Importance Sampling Adventure (Tweets)
- BRDF Definition (Blog Post)
- Mathematics of shading (Course Notes)
- 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)
- 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)
- Real-Time Subsurface Scattering Intro (Blog Post)
- Misunderstanding Multiscattering (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)
- Importance Sampling Techniques for GGX with Smith masking-shadowing (Blog Post)
- Lights And Shadows (Interactive Blog Post)
- Multiple Importance Sampling (Blog Post)
- Light Attenuation (Blog Post)
- Light Attenuation Formula Derivation (Stack Exchange)
- Multiple Scattering BRDF (Blog Post)
- Adventures In Triangle Sampling Part 1 (Blog Post)
- Image Based Lighting With Multiple Scattering
- Light Trees And The Many Lights Problem (Blog Post)
- Nonsingular Point Light Attenuation (Video)
- Adventures in Sampling Points on Triangles - Part 1 (Blog Post)
- Introduction to Lighting (Blog Post)
- Crash Course In BRDFs (Doc)
- Spherical Gaussians Series (Blog Series)
- Adventures in Hybrid Rendering (Blog Post)
- The Irradiance Volume (Paper)
- Advances In Rendendering, Graphics Research And Video Game Production (Slides)
Ambient Occlusion
- Screen Space Ambient Occlusion (Doc)
- Screen Space Ambient Occlusion - OGL Dev (Tutorial)
- Screen Space Ambient Occlusion - Learn OpenGL (Tutorial)
Papers
- A Taxonomy of Bidirectional Scattering DistributionFunction Lobes for Rendering Engineers (Paper)
- Can't invert the CDF? Triangle Cut Parametirzation of the Region Under The Curve (Paper)
- Efficient Screen-space SSS (Paper)
- Microfacet models for refraction through rough surfaces (Paper)
- Discrepancy as a Quality Measure for Sample Distributions (Paper)
- Bias In rendering (Paper)
- Optimally Combining Sampling Techniques for Monte Carlo Rendering (Paper)
- Multiple Importance Sampling Techniques for Monte Carlo Rendering (Paper/Coure Notes)
- Dynamic Many-Light Sampling for Real-Time Ray Tracing (Paper)
- Importance Sampling of Many Lights with Adaptive TreeSplitting (Paper)
- A Reflectance Model For Computer Graphics (Paper)
- Horizon Split Ambient Occlusion (Paper)
- Real Shading in Unreal Engine 4 (Paper)
- Reducing Shading on GPUs using Quad-Fragment Merging (Paper)
- Rearchitecting Spatiotemporal Resampling for Production (Paper)
- BRDF Importance Sampling for Polygonal Lights (Paper)
- An Area-Preserving Parametrization for Spherical Rectangles (Paper)
- Spatiotemporal reservoir resampling for real-time ray tracing with dynamic direct lighting (Paper)
- ReSTIR GI: Path Resampling for Real-Time Path Tracing (Paper)
- 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.
- Moment-Based Order-Independent Transparency (Paper)
Cameras, Exposure, Tonemapping
- 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)
- Moving Frostbite to PBR (PDF)
Misc
- 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)
- Mesh Shader Possibilities (Blog Post)
- 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)
- Geometric Derivation of the Irradiance of Polygonal Lights (Paper)
- Lossless Image Compression in O(n) Time (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)
- Half baked: Dynamic Occlusion Culling (Blog Post)
Depth
- 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)
Tutorials
- Learn OpenGL (Tutorial)
- Fragment Foundry (Tutorial)
- Intro to compute shaders (Blog Post)
- Scratchapixel (Tutorial)
- PBR Theory (Tutorial)
- FWidth (Tutorial)
Shader Editors
Floating Point
- 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)
Algorithms
- Visualizing Algorithms (Blog Port)
- Pathfinding with Cellular automota (Blog Post)
- QGrep Internals (Blog Post)
Networking
CPUs
- Branch Prediction Rundown (Blog Post)
- Introduction to dataflow graphs (Blog Post)
- SIMD at Insomniac Games (PDF)
- SSE Mind the gaps! (Blog Post)
- Hardware Effects (Repo)
- Write Combining is not your friend (Blog Post)
- Why do CPUs have multiple cache levels? (Blog Post)
- Software Optimization Resources (Guides) - Recommended
- Assembly Intrinsics (Blog Post)
- Cores don't like to share (Blog Post)
- AVX-512: When and how to use these new instructions
- By how much does AVX-512 slow down your CPU?
- Modern Microprocessors - A 90-Minute Guide! (Blog Post)
- Speed Limits (Blog Post) - Recommended
- Memory Disambiguation and Store Forwarding (Blog Post)
- Henry - StuffedCow (Blog)
- Measuring Reorder Buffer Capacity (Blog Post)
- Avoiding Instruction Cache Misses (Blog Post)
- It's done in hardware so it's cheap (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)
- Comments on timing short code sections on intel processors (Blog Post)
- A note on mask registers (Blog Post)
- This Goes To Eleven (Blog Post)
- Mutexes Vs Spinlocks (Blog Post)
- The Significance Of The x86 lfence Instruction (Blog Post)
- SMACNI to AVX512 the life cycle of an instruction set (PDF)
- Branch/cmove and compiler optimizations (Blog Post)
- Why Use LEA instead of ADD (Stack Overflow Answer)
- Using the LEA instruction for arbitrary arithmetic (Blog Post)
Retro
- 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)
Threading
- 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)
Sound
Collision
- 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)
Misc
- 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)