A curated collection of technical articles accumulated from around the web. Mostly graphics, games, math, and low level stuff.
Graphics - Techniques
- Real-time Global Illumination by Precomputed Local Reconstruction from Sparse Radiance Probes
- Rendering Vector Art on the GPU
- Atmospheric Scattering
- Maximizing Depth Buffer Range and Precision
- GPU Font Rendering
- Projection Matrix Tricks
- Normal Transforms - Inverse Transpose
- DOOM Fire Particle Effect
- Portal Rendering with Off-Screen Render Targets
- Command Buffers for Multi-Threaded Rendering
- Stateless, Layered, Multi-Threaded Rendering
- Bucketing Graphics Draw/State Calls
- Simulating Bokeh
- How is Virtual Texturing Actually Efficient?
- Programmatic Icosphere
- Modern LightMapping
- Fixing Frustum Culling
- Error of Depth Buffer Formats
- Visualizing Depth Buffer Precision
- Encoding floats to RGBA
- The Quest for Very Wide Outlines
- A Sampling of Shadow Techniques
- Sample Distribution Shadow Maps
- Spatiotemporal Blue Noise Textures
- Order Independent Transparency (Part 1)
- HPG 2022 Program
- Rendering Water in Horizon Forbidden West (Slides)
- Swapchains and frame pacing
- LatencyFleX: A new approach to game latency reduction
- Reverse Z (and why it's so awesome)
- Creating a Directed Acyclic Graph from a Mesh
- Recreating Nanite: LOD generation, Runtime LOD selection, Mesh shader time, Raytracing
- Beyond White Noise for Real-Time Rendering
- Filtering After Shading with Stochastic Texture Filtering
- Texture Streaming in Wicked Engine
- Arcball Interface
- Sparse Virtual Shadow Maps
- The details of transforming normals
Graphics - Color & Tone Mapping
- How Does HDR Work?
- What Makes a Good HDRI
- RGBM Color Encoding
- Automatic Exposure using a Luminance Histogram
- HDR Color Grading and Display in Frostbite
- Tone Mapping
- Oklab Color Space
- Khronos PBR Neutral Tone Mapper
- Why does the chromaticity diagram look like that?
- Color Space Confusion
Graphics - Renderers
- Rasterization on Larabee
- Tiled Deferred Shading
- Forward vs. Deferred Rendering
- Design Patterns for Low-Level Real-Time Rendering
- Deferred Rendering for Current and Future Rendering Pipelines
- Destiny's Multi-threaded Rendering Architecture
- How Unreal Renders a Frame
- How the Milton Renderer Works
- Filament Physically Based Graphics Engine (Android)
- Physically Based Shading at Disney
- Rendering Black Holes in Interstellar
- DOOM 2016 Graphics Study
- Red Dead Redemption 2 Graphics Study
- Metal Gear Solid V Graphics Study
- Rendering INSIDE - High Fidelity, low complexity
- A Primer On Efficient Rendering Algorithms & Clustered Shading
- Inside UE5
- Dreams (Learning From Failure) - Media Molecule
- Design and Evolution of the UberBake Light system
- Rendering Roblox
- Why are video game graphics still a challenge? Productionizing rendering algorithms
- Graphics Studies Compilation
- A Deep Dive into Nanite Virtualized Geometry
- Journey to Nanite (Slides)
- Journey to Nanite (Talk)
- Lumen in UE5 (Slides)
- Teardown Frame Teardown
- Bringing Nanite to Fortnite Battle Royale in Chapter 4
- Real-Time Rendering of Glinty Appearances using Distributed Binomial Laws on Anisotropic Grids
- Exploring Raytraced Future in Metro Exodus
- ExileCon Dev Talk - Evolving Path of Exile's Renderer
- Radiance Cascades
Graphics - 2D
- Fast 2D Rendering on the GPU
- 2D Rendering: Compositing Tree
- Writing a Custom Vector Graphics Renderer Part 1
- Why are 2D vector graphics so much harder than 3D?
- Rendering Text with Distance Fields
- 2D Visibility
- A Simple Solution for Shape Packing in 2D
- Parallel curves of cubic Béziers
- Simplifying Bézier Paths
- Motion Canvas
Graphics - Images
- Image Kernels Explained Visually
- Bitmap Sorter
- The Pannini Projection
- Texture Atlases, Wrapping, and Mipmapping
- Sparse Virtual Textures
- SSAO
- SSDO
- SMAA
- Color Grading & Correction
- Better Texture Filtering (Shadertoy)
- Beware of Transparent Pixels (Premultiplied Alpha)
- Bicubic filtering in fewer taps
- Catmull-Rom Sampler
- Improved Geometric Specular Anti-Aliasing
- Recipe for Temporal Anti-Aliasing
- Failed Adventure in Avoiding Temporal Anti-Aliasing
- Temporal AA Starter Pack
- Separate your filters
- Decoupled Visibility Multisampling
- Quite OK Image Format
- Software VRS with Visibility Buffer Rendering
- Accelerating Raytracing Using Software VRS
- Stochastic Texture Filtering
- Circularly symmetric convolution and lens blur
- Temporal AA and the quest for the Holy Trail
- SVD Image Compression, Explained
- This is the Difference of Gaussians
- Learned Image Compression
- AAA - Analytical Anti-Aliasing
Graphics - Resources
- Intro to Rendering Techniques
- GPU Gems 3
- Journal of Computer Graphics Techniques
- A Trip Through the Graphics Pipeline - 2011
- Graphics Pipelines for Young Bloods
- The Book of Shaders
- 3D Game Shaders for Beginners
- TinyRenderer Software 3D Renderer Tutorial - Part 1
- Real-Time Rendering for Artists
- Graphics Programming Black Book
- Physically Based Rendering (text)
- How to Read a Realistic Rendering Paper
- NVIDIA Developer blog: advanced API performance
- Advanced API Performance: Clears
Graphics - Academia
- What Makes a (Graphics) Systems Paper Beautiful
- Writing your first ACM SIGGRAPH / TOG paper
- My first 100 days as a professor
Graphics - Ray/Path Tracing
- Ray Marching & Signed Distance Functions
- A Signed Distance Fields Rendering Journey
- Creating Content with Signed Distance Functions
- Modeling with SDFs
- Business Card Ray-Tracer
- WebGL Path Tracing
- Creating a Volumetric Ray Marcher
- Real-Time Raytracing in UE4
- Rendering Moana with pbrt
- Fractal Engine
- Revisiting the Postcard Raytracer with CUDA and OptiX
- Marble Marcher
- Raymarched Explosion in C++
- Path Tracer Project Report
- Megakernels Considered Harmful: GPU Wavefront Path-Tracing
- Ray Tracing a Tiny Procedural Planet
- Virtual Femto-Photography
- Crafting a real-time path tracer for minecraft RTX
- Ray Tracing: The Rest of Your Life
- Animating Noise for Integration Over Time
- Screen Space Path Tracing
- Monte Carlo Estimators for Differential Light Transport
- Reducing Acceleration Structure Memory with RTXMU
- Spatiotemporal reservoir resampling for real-time ray tracing with dynamic direct lighting
- Fast Volume Rendering with Spatiotemporal Reservoir Resampling
- Light transport matrices, SVD, spectral analysis, and matrix completion
- Real-time Neural Radiance Caching for Path Tracing
- Dynamic, Noise Free, Screen Space Diffuse Global Illumination
- Unreal Engine 5 goes all-in on dynamic global illumination with Lumen
- Kajiya Global Illumination Overview
- Temporally Stable Real-Time Joint Neural Denoising and Supersampling
- Polarization in Path Tracing (Mitsuba 3)
- Visualizing General Relativity
- Fast, Branchless Ray/Bounding Box Intersections, Part 3: Boundaries
- Reading Veach’s Thesis
- Cyberpunk 2077’s Path Tracing Update
- Coupling Conduction, Convection and Radiative Transfer in a Single Path-Space: Application to Infrared Rendering
- Crash Course in BRDF Implementation
- Solving Self-Intersection Artifacts in DirectX Raytracing
- The Missing Primary Ray PDF in Path Tracing
- Fast Denoising with self-stabilizing recurrent blurs
- VNDF importance sampling for an isotropic Smith-GGX distribution
- N-BVH: Neural ray queries with bounding volume hierarchies
- Implementing General Relativity: Rendering the Schwarzschild black hole
- Machine Learning on the GPU - Case Study: Open Image Denoise
- Rendering Tiny Glades With Entirely Too Much Ray Marching
Graphics - Ray/Path Tracing - ReSTIR
- ReSTIR GI for Specular Bounces
- ReSTIR Reading List
- Lecture: TAA & ReSTIR
- Understanding The Math Behind ReStir DI
- Understanding the Basics of ReSTIR DI
- A Gentle Introduction to ReSTIR
- A Gentler Introduction to ReSTIR
- Combining Resampled Importance and Projected Solid Angle Samplings for Many Area Light Rendering
- Dynamic diffuse global illumination
Graphics - Simulation & Animation
- GPU Based Clay Simulation and Rendering
- Real-Time Simulation and Rendering of 3D Fluids
- WebGL Fluid Simulation Guide/Example
- SpaceX GPU Simulation
- GPU Fluid Simulation
- PIC/FLIP Fluid Simulation
- Game Developer's Spring-Roll-Call
- Simulating worlds on the GPU
- Cloth Self Collision with Predictive Contacts
- Physics Engine Development - Metaprogramming, serialization, IPC, etc.
- Simulating Crowds in Planet Coaster
- Continuous Time Simulation
- Procedural Animation
- Modeling Erosion
- Questions about L-Systems
- Eroding Fractal Terrain with Virtual Raindrops
- Procedural Spider Animation in Araknoids
- Papercraft with Blender
- Shaded relief maps in Blender
- Realtime Fluid Simulation: Projection
- Fluid Simulation: Reintegration Tracking
- Real-time rendering of volumetric clouds
- C++ audio mixing library design
- Ten Minute Physics
- Making a 2D soft-body physics engine
- A Practical Walk-on-Boundary Method for Boundary Value Problems
- Simulating Fluids, Fire, and Smoke in Real-Time
- Incremental Potential Contact
- Fix Your Timestep!
- Numerical Relativity 101: Simulating spacetime on the GPU
- Physics-Based Simulation Book
- Let's talk about Animation Quality
Graphics - Machine Learning
- Phase-Functioned Neural Networks for Character Control - Demo
- Instant Neural Graphics Primitives with a Multiresolution Hash Encoding
- Learning for 3D Vision
- GARF: Gaussian Activated Radiance Fields for High Fidelity Reconstruction and Pose Estimation
- Testing GARFs
- AI assisted graphics: Character modeling
- Neural Denoising and Motion
- Isotropic Neural Cellular Automata
- Perspectives on Diffusion
- 3D Gaussian Splatting for Real-Time Radiance Field Rendering
- Making Gaussian Splats smaller
- Iterative 𝛼-(de)Blending: a Minimalist Deterministic Diffusion Model
- XCube: Large-Scale 3D Generative Modeling using Sparse Voxel Hierarchies
- Equivariant Neural Networks
- Tutorial on Diffusion Models for Imaging and Vision
Graphics - Voxels
- Voxel-Based Global Illumination
- Interactive Indirect Illumination using Voxel Cone Tracing
- Cascaded Voxel Cone Tracing in The Tomorrow Children
- Implementing Voxel Cone Tracing
- Voxel Cone Traced Global Illumination
- GigaVoxels
- Real-Time Voxels (blog)
- Dual Contouring
- TransVoxel Algorithm
- TransVoxel Implementation
- Terrain Engine: Dual Contouring
- Terrain Engine: Volume Generation & CSG Tree
- Voxel Instancing
- Voxel Dual Contouring
- How Voxels Became 'The Next Big Thing'
- Polygonising a scalar field
- Voxel Displacement Renderer
Graphics - Swedish Cubes
- Ray-Box Intersection Algorithm for Efficient Dynamic Voxel Rendering
- Rendering Huge Amounts of Voxels
- Voxel Quest
- Cave Culling in Minecraft
- Meshing in a Minecraft Game
- Meshing in a Minecraft Game Part 2
- Ambient Occlusion for Minecraft-like Worlds
- Minecraft Super Duper Graphics Pack
- Voxel Editor
- MagicVoxel
- MagicaVoxel Shaders
- Vertex Positions to Packed Element Arrays
- Compact Cube Meshes & Unity
- VBOs or Geometry Shaders? (Or Instancing?)
- Greedy Voxel Meshing
- Backface Culling
- LOD for Voxels
- Flood-Fill Voxel Lighting
- Voxel Dynamic Lighting and Shadows
- Voxel Editor Evolved
- Water in DwarfCorp
- Voxel Chunk Frustrum Culling
- Seed of Andromeda - Region File System
- A Voxel Renderer for Learning C/C++
Graphics - GPUs
- RenderDoc Debugger
- NVIDIA GPU Threading / Inefficient Design
- Where is OpenCL Used?
- Interactive CUDA
- Minimal D3D Framework Code
- D3D Code Samples
- Setting up D3D11
- D3D12 Programming Guide
- Pixel Art Games and nSight Shader Analysis (HMH)
- Metal starter code
- GPU Compute Model Terminology Cheat Sheet
- Gentle Introduction to modern GPU Architecture
- GPU Optimization for GameDev list
- Optimizing Parallel Reduction in CUDA
- Optimizing GPU occupancy and resource usage with large thread groups
- Shader Execution Reordering White Paper
- Cooperative Matrix Multiply
- Shader Execution Reordering: Nvidia Tackles Divergence
- Data Parallel Multi-GPU Path Tracing using Ray Queue Cycling
- Implementing a GPU's Programming Model on a CPU
- Segmented Sort and Locality Sort
- Implementing a GPU-driven debug line renderer
- How to Optimize a CUDA Matmul Kernel for cuBLAS-like Performance
- GPUs Go Brrr
- A quick introduction to workgraphs
- GPU Programming Primitives for Computer Graphics
- Fixing The GPU
Graphics - OpenGL
- LearnOpenGL
- Rendering Without Vertex Data
- Basic Shader Examples
- What State is Stored in a VAO?
- Modern OpenGL Text Rendering
- Using OpenGL Like Vulkan
- OpenGL Array Textures
- OpenGL Instancing
- OpenGL Lighting and More
- Check if an Object is Outside the Clipping Volume
- OpenGL Constants List
- Multisampling
- Shadow Mapping
- WebGL PBR Example
- Bindless rendering setup
- Introduction to Compute Shaders
- OpenGL 3.1 on Asahi Linux
Graphics - Vulkan/D3D12/WebGPU
- Vulkan Swapchains & presentation
- GPU Memory Pools in D3D12
- Descriptors are Hard
- Optimising A AAA Vulkan Title on Desktop
- Vulkan in 30 Minutes
- Vulkan Tutorial
- Vulkan Examples and Demos
- Vulkan 101
- VkMark
- A Guide to Vulkan Layers
- Writing an efficient Vulkan renderer
- Vulkan Multithreading Overview
- The GPU Banana Stand (Use.GPU)
- Vulkan Memory Types on PC and How to Use Them
- Yet another blog explaining Vulkan synchronization
- Debugging VK_ERROR_DEVICE_LOST with Nvidia Device Diagnostics
- D3D12 Work Graphs Preview
- Render graphs and Vulkan — a deep dive
- Workarounds for issues with mesh shaders + Vulkan + HLSL
Graphics - Shaders
- Single-Pass Wireframe Rendering
- RayLib Shaders
- Validator
- Noise
- Making a Rain on a Windshield Shader
- Making The Drive Home shader
- Shader_Minifier
- Stupid OpenGL Shader Tricks
- Mist Shadertoy
- LearnOpenGL - Advanced GLSL
- 3D Game Shaders for Beginners
- Avoiding Shader Conditionals
- Protean Clouds (Shadertoy)
- Voronoi Noise (Shadertoy)
- A Scalable and Production Ready Sky and Atmosphere Rendering Technique | (Shadertoy)
- Procedural Sky (OpenGL)
- WebGL Noise
- Time wrap in shaders
- Quake 2 RTX Checkerboard interleave
- memory locality optimization in the Claybook GPU particle simulator
- Tangent Spaces and Diamond Encoding
- Winding Numbers
- Death To Shading Languages
Math - Geometry
- Math for Game Developers
- Intro to Quaternions
- Visualizing Quaternions
- Let's Remove Quaternions - Geometric Algebra
- Hacking Quaternions - nlerp + spline
- Signed Distance Functions
- Implementing Inverse Kinematics
- Making Splines Useful
- Programmer's Guide to Polynomials and Splines
- Counterintuitive Properties of High Dimensional Space
- Fundamentals of Grassmann Algebra
- A Faster Quaternion-Vector Multiply
- The Separating Axis Theorem
- Discrete Differential Geometry
- Groups and Group Convolutions
- Compressing 3D Unit Vectors
- Conformal Geometry Processing
- Inside Curved Spaces
- Monte Carlo Geometry Processing
- Fast Voronoi Diagrams and Distance Fields with Jump Flooding
- Polyhedra Viewer
- Dirac's belt trick, Topology, and Spin 1/2 particles
- Sphere Eversion
- A Robust Method to Extract the Rotational Part of Deformations
- Course Notes: Geometric Algebra for Computer Graphics
- Klein (an implementation of 3D Projective Geometric Algebra)
- DMesh3: A Dynamic Indexed Triangle Mesh
- Manifolds: A Gentle Introduction
- Why is a Gaussian distribution on high dimensional space like a soap bubble?
- Penrose tiling rewrite rule
- An algorithm for irregular rectangles that map 1:1 with a square grid
- Spectre aperiodic monotile
- Boundary Value Caching for Walk on Spheres [SIGGRAPH 2023]
- Reach For the Spheres: Tangency-Aware Surface Reconstruction of SDFs
- Finding Real Polynomial Roots on GPUs
- Faster quaternion product rotations
- Projective Geometric Algebra
- The Triangle is Dead, Long Live the Triangle!
Math - Cryptography
- Elliptic Curve Cryptography
- Cryptanalysis of Meow Hash
- Implementing My Own Crypto
- NaCl Crypto
- A from-scratch tour of Bitcoin in Python
Math - RNG / Procedural Generation
- Maze Generation
- Maze + Room Generation
- Terrain Generation from Noise
- Polygonal Terrain Generation
- What Does Randomness Look Like?
- Generating Islands
- 3D Cave Generation
- Generating Trees in Blender
- Combining Noise Functions
- ProcGen Resources List
- Generating City Road Maps
- Procedural Structures in Tilemaps
- SIMD FastNoise
- Top-Down Cave Gen
- RoboHash
- PCG Family of pseudo-random generators
- Right-Triangulated Irregular Networks
- Fractal Brownian Motion
- Spaceship Generator
- 3D Cellular Automata
- Primer on Repeatable Random Numbers
- Noise-Based RNG
- Three Ways of Generating Terrain with Erosion Features
- Procedural Worlds from Simple Tiles
- The Perlin Problem: Moving Past Square Noise
- Fibonacci Fun
- MarkovJunior
- ProcGen Resources
- How Pitfall Builds its World (Linear Feedback Shift Registers)
- bleuje : Animations
- Procedurally generated bitmap art
- SquirrelNoise5
- Infinite Photorealistic Worlds using Procedural Generation
- Modeling & Graph Grammars
- Using a RNN for 2D Tile Map Synthesis
- An RNG that runs in your brain
- Better Mountain Generators That Aren't Perlin Noise or Erosion
- One Noise to Rule Them All
- Procedural generation with workgraphs
- My Favorite Tools + Techniques for Procedural Gamedev
- Watabou's Procgen Arcana
- Summing Blue Noise Octaves Like Perlin Noise
- Probability-Generating Functions
Math - Monte Carlo
- Markov Chain Monte Carlo Without all the Bullshit
- An Introduction to Stochastic Calculus
- Markov Chain Monte Carlo Methods, Rejection Sampling and the Metropolis-Hastings Algorithm
- Hamiltonian Monte Carlo
- Monte-Carlo Graph Search from First Principles
- On the Convergence of the Unadjusted Langevin Algorithm
Math - Misc.
- For Mathematicians, = Does not mean Equality
- Discrete Math Overview/Recommendations
- Deriving the Boltzmann Distribution via Atmospheric Density
- How to Read Math
- Eigenvalues and Vectors
- Using Modern SAT Solvers
- Polynomial Approximating Sin/Cos
- Efficiently Computing Fibonacci
- Classic Math Books
- Group Theory and the Rubik's Cube
- Visual Information Theory
- Information Theory for Intelligent People
- Going Critical
- Tetris is NP-Complete
- What is the Poisson Distribution?
- A Mathematician's Lament
- Poisson's Equation
- The Moessner Miracle
- Improving the fast inverse square root
- Natural Number Game (lean)
- The Insolubility of the Quintic without Galois Theory
- Real analysis problem solving strategies
- A maximally-dense encoding for n-choose-k
- A Short Introduction to Optimal Transport and Wasserstein Distance
- Seven Sins of Numerical Linear Algebra
- Special relativity and Middle-Earth
- Incremental Least Squares Curve Fitting
- SymPy makes math fun again
- The Calculus of Variations
- What Is the Complex Step Approximation?
- Closed-Form 3x3 Matrix Decompositions
- Derivative AT a Discontinuity
- Learning Solver Design: Automating Factorio Balancers
Math - Summer of Math Exposition
- What Lies Between a Function and Its Derivative?
- The Shadowy World of Umbral Calculus
- Transfer Functions - Of Sound Mind
- Why There's 'No' Quintic Formula (proof without Galois theory)
- Dirac's belt trick, Topology, and Spin ½ particles
- 1 Billion is Tiny in an Alternate Universe: Introduction to p-adic Numbers
- Percolation: a Mathematical Phase Transition
- If it probably exists, then it does
- What is the graph of x^a when a is not an integer? An unusual look at familiar functions
- Why you can't solve quintic equations (Galois theory approach)
- Seven Dimensions
- Wavelets: a mathematical microscope
CS - Algorithms
- A*
- Papers I have Loved (Casey Muratori) [marching cubes, quaternions, GJK collision algorithm]
- Binary Space Partitioning
- The Competitive Programmer's Handbook
- Spacial Search Algorithms
- Fantastic Algorithms and Where to Find Them
- Time, Clocks, and the Ordering of Events in a Distributed System
- Solving Every Sudoku Puzzle
- Generating Quotes with Markov Chains
- PageRank
- GJK and Expanding Polytope Explanation
- FSM Designer
- Generative Algorithms
- What's your favorite algorithm? Ask HN
- Wavefunction Collapse
- The Right Answer to Collaborative Editing
- Solving DP Problems
- Dynamic Programming: Seam Carving Improved
- Diffing Algorithms in Git
- Rectangle Packing
- Markov Chains for Procedural Buildings
- Cache-Oblivious Algorithms
- The Xi text engine CRDT
- CRDTs: The Hard Parts
- 5000x faster CRDTs
- Xi Algorithms/Rope
- Intelligent brute forcing
- Rapidly Solving Sudoku, N-Queens, Pentomino Placement, and More, With Knuth’s Algorithm X and Dancing Links.
- The story behind the Packing Chromatic paper
- Possibly all the ways to get loop-finding in graphs wrong
CS - Data Structures
- Masstree: Cache-Friendly trie/b-tree
- Hash-Array-Mapped Trie
- Bloom Filter
- Skip List
- Rope
- Esoteric Data Structures and Where to Find Them
- Designing a Fast Hash Table
- Blender Mesh Structure
- Hash Array Mapped Trie Implementation
- The Only Undoable CRDTs are Counters
CS - Concurrency
- Lock-Free Work Stealing
- Multithreaded Game Engine Design
- Designing a Parallel Game Engine
- Lock-free Dequeue in C++
- Game Async API & Virtual Memory Design
- Designing a Lock-Free, Wait-Free Hash Map
- Concurrency is not Parallelism
- Structured Concurrency: Go statement considered harmful
- Structured Concurrency in High-level Languages
- Concurrency - Why is Memory Reclamation so Important?
- Making the Tokio Scheduler 10x Faster (Work-Stealing)
- An Interesting Lock-Free Queue
- Resource efficient thread pools in Zig
- Parallelizing the Naughty Dog engine using fibers
- 2PLSF: Two-Phase Locking with Starvation-Freedom
- Designing A Fast Concurrent Hash Table
- What every systems programmer should know about concurrency
Machine Learning
- Visualizing MNIST
- Is AI Riding a One-Trick Pony? (Backprop)
- Machine Learning - Spotify Discover Weekly
- 3Blue1Brown Deep Learning Playlist
- A Visual Guide to Evolution Strategies
- Build a Neural Network
- Neural Algorithm of Artistic Style
- Unsupervised Image-to-Image Translation Networks
- A Neural Network in 10 Lines of C++
- Learning to write programs that generate images
- Code Generation and Semantic Parsing - Hearthstone Cards
- Empiricism and the Limits of Gradient Descent
- AlphaStar - Mastering Starcraft II
- Understanding Convolutions
- Visualizing Representations
- Convolutional Nets: A Modular Perspective
- 3D Style Transfer for Video
- Lessons learned building an ML trading system
- Alien Dreams: An Emerging Art Scene
- The Bitter Lesson
- Transformers from Scratch
- World Building With GPT
- Toy Models of Superposition
- Will scaling work?
- Analyzing and Improving the Training Dynamics of Diffusion Models
- Trilinear Point Splatting for Real-Time Radiance Field Rendering
- The Next Great Scientific Theory is Hiding Inside a Neural Network
- A Visual Dive into Conditional Flow Matching
Games - Design
- Pacing Puzzle Games
- How to Design Deep Games - Jon Blow
- Inspire Interview: Jon Blow
- The Medium is the Message - Jon Blow
- The Art of The Witness
- Truth in Game Design
- Advice on Designing Maps/Levels
- 30 Things I Hate About Your Game Pitch
- 50 Game Camera Mistakes
- Factorio's Modding API
- Open-Ended Puzzle Design at Zachtronics
- How to Make Great Puzzle Game
- Leveraging ML for Game Development
- Cursed Problems in Game Design
Games - Business
- The Cost of Games
- Indie Polish
- Finishing
- Lessons Learned from a 5-year Indie Dev Cycle
- How do I Release my Game?
- Free to Play Model Debate
- Ultimate Legal Guide
- Put Your Name on Your Game
- Riot's Approach to Anti-Cheat
- Fortnite Service Outage Postmortem
Games - Misc.
- Useful Game Dev. Code Snippets
- DOOM Behind the Music
- Pixel Art Advice
- Pen Plotter Art & Algorithms
- Learning from Terminals to Design the Futures of User Interfaces
- Learning Synths
- Voronoi Split Screen
- Marvel's Spider-Man: A Technical Postmortem
- Useful Snippets
Software - Technique
- Handmade Manifesto
- Compression-oriented Programming
- 5 Rules of Programming
- Making Wrong Code Look Wrong
- Everything is Broken
- Why is nearing Completion so De-motivating?
- Jon Blow - Techniques for dealing with lack of motivation, malaise, depression
- Jon Blow - Unit Testing and TDD
- Software Testing Anti-patterns
- Writing Small Programs in C
- Writing Minimalist C Libraries
- Programming Paradigms all Programmers Should Know
- Designing and Evaluating Reusable Components
- The Wrong Abstraction (is worse than duplication)
- Data Oriented Design Slides
- OOP is Dead, Long Live Data Oriented Design
- Practical Examples in Data Oriented Design
- Specs and Legion, two very different approaches to ECS
- Producing Wrong Data Without Doing Anything Obviously Wrong!
Software - Culture
- Confessions of a UE4 Engineering Firefighter
- How do You Make Programmers Work 60-80 Hour Weeks?
- NASA Development Philosophy
- General and Surprising
- Electron is Flash for the Desktop
- How to do Code Reviews Like a Human
- Things You Should Never Do - Rewrite
- Building Software Capital
- Don't Let Architecture Astronauts Scare You
- Ideology
- Containers Won't Fix Your Broken Culture
- Learning to Program is Getting Harder
- The Bug-O Notation
- UTF8 Everywhere
- Taxonomy of Tech Debt
- Why Don't People Use Formal Methods?
- Software Disenchantment
- The Lesson to Unlearn (Hacking Bad Tests)
- How to Write Better C Libraries
- The Thirty-Million Line Problem
- John Carmack on inlined code
- Tips for Giving Clear Talks
Software - Misc. Tools
- Color Theming
- Monospace Fonts
- Free Low-Poly Animal Meshes
- Free to Use Sounds
- Free Icons
- Google Sanitizers
- Quick C++ Microbenchmark
- Godbolt Compiler Explorer
- C++ Development with VS Code
- Excel
- Using ffmpeg
- Tools for Small Project Management
- Tools for Writing Books
- rr Debugger
- msdfgen
- Free HDRI Environment Maps
- Free VDB Volumes
- Intel Graphics Samples
- Vector.js
- Three D Scans
Software - Misc. Libraries
- Single-File Libraries
- STB
- SDL2
- GLFW
- ImGui
- ImGui Profiler
- ImTui
- SEE2 Trig Functions
- Easy Drawing Tablet Input
- Slug Font Rendering
- C++ Memory Profiler
- TinyHeaders
- SoLoud
- Mesh Optimizer
Languages - Functional Programming
- Functional Programming Jargon
- Mostly Adequate Guide to Functional Programming
- Functional Programming in C++ -A Monad is a Monoid in the Category of Endofunctors
- Refactoring via Recursion and CPS Conversion
- What makes dependent type theory more suitable than set theory for proof assistants?
- Notes on GADTs
- I'm betting on Call-by-Push-Value
- How OCaml type checker works -- or what polymorphism and garbage collection have in common
- Soundly Handling Linearity
- Functional programming languages should be so much better at mutation than they are
- Higher-kinded bounded polymorphism
- Damas-Hindley-Milner inference two ways
- Adding row polymorphism to Damas-Hindley-Milner
- Scientific computing with confidence using typed dimensions
- Tree calculus
- Proofs about a Folklore Let-Polymorphic Type Inference Algorithm
Languages - Compilers
- The Programming Language Pipeline
- Language Theory for the Working Programmer
- Deterministic Finite Atomata
- Probabilistic Context-Free Grammar
- Using Types Effectively
- Building a Simple Interpreter
- Embedding LuaJIT
- Terra - Low Level Embedded Lua Metaprogramming
- What I Learned Making my own JIT Language
- A Compiler Writing FA99 Journey
- Expression parsing algorithm
- Optimizations in C++ Compilers
- Lexical Analysis Strategies
- (Go) Finding unreachable functions with deadcode
- Compiling With Constraints
- Compilers for free with weval
- Zig-style generics are not well-suited for most languages
- AUTOMAP: How to do NumPy-style broadcasting in Futhark (but better)
- The power of predicate pushdown
- The Flix Programming Language
- Koka: A Functional Language with Effect Types and Handlers
- Abstract interpretation in the Toy Optimizer
- Lightweight region memory management in a two-stage language
- optimizing the Ion compiler backend
- A DSL for Peephole Transformation Rules of Integer Operations in the PyPy JIT
- Compiling Pattern Matching
- Our optimizers need a rethink
- You can use C-Reduce for any language
- Fidget
- Explain mapping between OCaml memory model and C
Languages - Rust
- Embedded Rust Setup Assignment
- You can't Rust that
- Periodic table of Rust Types
- Rust Pointers for C Programmers
- Micro-controllers with Rust
- Lock-free Dequeue in Rust
- Entity Systems and the Borrow Checker (Rant)
- Rust Game Dev Experience
- Learn Rust with Entirely too Many Linked Lists
- A half-hour to learn Rust
- How to debug rust with visual studio code
- Streams in Rust
- Leaving Rust gamedev after 3 years
Languages - LLVM
- The LLVM Toolchain
- Taming Undefined Behavior in LLVM
- LLVM Tutorial
- LLVM Architecture
- LLVM for Grad Students
- Using libclang to Parse C++
- How Clang Compiles a Function
- Building Useful ClangTools
- Complete Guide to LLVM
Languages - C
- Generics in C
- C Preprocessor Magic
- GCC Function Names
- Auto-vectorization in GCC
- C Reflection with Clang
- Writing a C Compiler
- Lisp in 200 Lines of C
- Making Smaller C/C++ Binaries
- Making a Minimal Container Library in C
- Embedded - What happens before main() is executed?
- Why Aren't there C Conferences?
- Some Dark Corners of C
- Some things every C programmer should know about C
- Few lesser known tricks, quirks and features of C
- Optimizations enabled by -ffast-math
- Type-erased generic functions for C: A modest non-proposal
Languages - C++
- rvalue References
- C++11 Multithreaded Memory Model
- Modern C++ Features Cheat-Sheet
- Functional Programming in C++
- Low-Latency C++
- Defer in C++11
- The C++ Bestiary
- Rethinking Exceptions
- Curiously Recurring C++ Bugs at Facebook
- Low-Latency C++ for Fun and Profit
- Regular Expressions Redefined in C++
- Metaclasses Proposal Summary
- C++17
- Constexpr Everything
- Orthodox C++
- The Culture of Complexity
- Live C++ (hot reloading)
- C++ Without Redundancy
- C++ Advice
- Is C++ Fast?
- std::launder
- clang consumed annotations
- C++ Programming Tips
- 105 STL Algorithms in Less Than an Hour
- Non-Conforming C++ - The Secrets the Committee is Hiding from You
- There Are No Zero-Cost Abstractions
- Path Tracing 3 Ways: C++ Style Study
- libc++'s implementation of std::string
- The Surprising Limitations of C++ Ranges
- How to add C++ structured binding support to your own types
- All C++20 Core Features with Examples
- C++ Exceptions under the hood
- Modern C++ Lamentations - Pythagorean Triples
- Provenance and Concurrency
- I Have No Constructor, and I Must Initialize
- The two factions of C++
Languages - Misc.
- Jai Demo Playlist
- There Will Be Build Systems
- How Media Molecule Does Serialization
- Go Pragmas
- dartfmt
- Python Decorators
- Perils of Constructors
- Rethinking Visual Programming with Go
- K
- Featherweight Go
- We need visual programming. No, not like that.
Computer Engineering - Hardware
- NAND Game
- Building an 8-bit Breadboard Computer
- Making Logic Gates from Transistors
- Inseparable from Magic - Manufacturing Modern Computer Chips
- Building a Computer to play Tetris in Conway's Game of Life
- Implementing FizzBuzz on an FPGA
- Why Spend 1.5 Months on a Gameboy Emulator?
- Emulating the Wii vs. the GameCube
- Clocks for Software Engineers
- Bedroom Electronics Factory
- Why Skylake CPUs are Sometimes 50% Slower - C# Spinlocks
- Agner's CPU Blog - Ryzen
- Documentation for the RISC-V BOOM CPU
- Modern x64 Architectures and the Cache
- A look at the die of the 8086 processor
- Inside the 8086 processor, tiny charge pumps create a negative voltage
- Building a Homebrew Console
- Can Doom Run It? An Adding Machine in Doom
- Weird things I learned while writing an x86 emulator
- SMACNI to AVX512 the life cycle of an instruction set
- Weird things I learned while writing an x86 emulator
- Why those particular integer multiplies?
- The Alder Lake shlx anomaly
Computer Engineering - Memory
- What Every Programmer Should Know About Memory
- jemalloc
- Implementing/Debugging malloc
- Testing Memory Allocators
- RAM Refresh Cycles
Computer Engineering - Security
- X86 Design Flaw Memory Sinkhole
- Psychological Warfare in Reverse Engineering
- Hardware Backdoors in x86
- Spectre & Co Overview
- Breaking the x86 ISA
- PS4 Kernel Crashdump
- Finding a CPU Bug in the Xbox 360
- Finding Statically-Linked Vulnerable Code
- How a double-free bug in WhatsApp turns to RCE
- Adventures in Smart Buttplug Penetration
- How we recovered over $300k of bitcoin
- 7-Zip Uninitialized Memory to Remote Code Execution
- Reverse engineering unc0ver in 4 hours
- It's fine just ship it - unsecured web connected interfaces
- Collection of botnets
- Zenbleed
Computer Engineering - Low Level Programming
- Computer Systems: a Programmer's Perspective
- Branch Prediction
- AVX512 Benchmarks
- Generating Executable Files from Scratch
- ASM Debugging with GDB
- Disabling IME
- Ten Years of the TTL CPU
- Bit Hacks
- RDTSC vs. QueryPerformanceCounter
- Using Val/call/cachegrind
- Why is this C++ Faster than Hand-Written ASM?
- Optimization Resources
- Don't Use Inline ASM
- Are Jump Tables Always Fastest?
- Testing all Floats
- CPU Utilization is Wrong
- The Best Optimizer is between Your Ears
- Using SSE
- Riot Profiling C++
- SIMD String Prefix Matching
- AVX512 Whitespace Removal
- When FFI Calls Beat Native C
- Rules of Optimization
- Moustache Visual Debugger Demo
- Branchless UTF8 Decode
- Normalized Byte Multiplication
- Performance Optimization, SIMD, Cache
- Going Nowhere Faster
- Formatting Floats
- Adventures in Data-Oriented Design - Hierarchical Data
- Where do Interrupts Happen?
- Anatomy of a High-Performance Matrix Convolution
- Optimizing the Interpreter Loop
- What Every Computer Scientist Should Know About Floating-point Arithmetic
- The radix 2^51 trick (amortizing carries)
- Bit Twiddling Hacks
- Parsing Protobuf at 2+GB/s
- Beating the L1 cache with value speculation
- Herbie float precision
- Speeding up atan2f by 50x
- Optimizing sorting in D - doing more work/branchless
- Fastest fizzbuzz
- My approach to optimization
- Examples of floating point problems
- Fast, Near Lossless ‘Compression’ of Normal Floats
- Float Compression Series
- What a good debugger can do
- Implementing a GPU's Programming Model on a CPU
- Beating OpenBLAS and MKL in 150 lines of C Code: A Tutorial on High-Performance Matrix Multiplication
- How we get to main()
- tolower() with AVX-512
- The Fastest Mutexes
Computer Engineering - Operating Systems
- Let's Write a Kernel
- Handmade XCB Platform Layer
- Recompiling NES Games with LLVM
- Simple Heap Allocator
- What if Main is not a Function?
- Keyboard Latency
- Bare Bones OS Tutorial
- OS Abstractions with Plan 9
- Write a Shell in Rust
- Write your own Virtual Machine
- File system from scratch in Rust
- Surprisingly Slow
- A Kernel Hacker Meets Fuchsia OS
- Linux in a Pixel Shader - A RISC-V Emulator for VRChat
- When will there be a sandboxed bytecode-vm userland ipc-only microkernel db-filesystem networked app-package operating system?
Computer Engineering - Operating Systems - Windows
- Avoiding the CRT on Windows
- Blog - Raymond Chen
- What Just Ran on the Windows Console?
- Requesting the Dedicated GPU
- Windows AsyncIO for Unix Programmers
- Loading a DLL from Memory
- Signing a Windows EXE
- Avoiding the Visual C++ Runtime
- Everything you ever wanted to know about DLLs
- Using/Avoiding the Windows Debug Heap
- Switching a Window to Fullscreen and Back
- D's Windows Platform Layer
- Lockless Programming Considerations
- Make MSVC Compile in Parallel
- Inside the Windows Command Line
- History of Windows - Part 1
- Understanding ReadDirectoryChangesW
- Making Windows Slower - Process Destruction, Not Called Functions
- Making Windows Slower - Making VirtualAlloc Arbitrarily Slow
- Making Windows Slower - File Access and Deletion
- Making Windows Slower - Process Creation
- Xinput (Odin)
- MSVC Flag: d2cgsummary
- MSVC Flag: d1reporttime
- 24 Core CPU and I can't Move my Mouse
- 24 Core CPU and I Can't Type an Email Part 1 Part 2
- 63 Cores Blocked by 7 Instructions
- n^2 again, now in WMI
- Moving window handling to another thread example
- Properly handling keyboard input
- Making Your Game Go Fast by Asking Windows Nicely
- Please Restore Our Registers When You’re Done With Them
- timeBeginPeriod function
Computer Engineering - Operating Systems - Linux
- Detecting GDB
- 30 Interesting Shell Commands
- Capture the output of a child process in C
- Linux Containers in 500 Lines of Code
- 10 Things I Wish I'd Known about Bash
- Inside the Linux Boot Process
- Linux Program Startup
- Julia Evan's Linux Drawings
- Doing things in Bash Safely
- Command-Line Tools can be 235x Faster than your Hadoop Cluster
- Using GDB
- Huge-Page Swapping
- Forgotten Unix CLI Commands
- Virtual-Memory Assisted Buffer Management
Networking
- How Multiplayer Games Sync their State
- What Every Game Programmer Needs to Know About Networking
- Overwatch Gameplay Architecture and Netcode
- Beej's Guide to Network Programming
- Game Networking Blog
- Networked Physics Blog
- Age of Empires II Multiplayer Networking
- Illustrated TLS Connection
- DNS Hijacking without Exploitation
- Networking Protocols for Anyone who Understands a Programming Language
- Making a Multiplayer FPS in C++ - Part 1
- Backend Programming in C
- Optimizing Web Servers (nginx) for High Throughput and Low Latency
- How Browsers Work
- What Happens When You Type google.com...
- It's Time to Kill the Web (as an applications platform)
- BSD, C, httpd, SQLite
- Let's Build a Simple Database
- Favorite PostgreSQL Queries
- Why databases use ordered indexes but programming uses hash tables
- Netflix: What Happens When You Press Play?
- Serving Netflix Video Traffic at 400Gb/s and Beyond
Technical History & Stories
- The 640K Barrier
- Understanding Pac-Man Ghost Behavior
- Wolfenstien 3D - Game Engine Black Book
- 0 Based Arrays - Dijkstra
- Flash Games Postmortem
- The Ultimate Garbage Collector
- The Case of the 500-Mile Email
- LAND OF LISP
- Inside the Xerox Alto's Display
- Visualizing the Sound of Dial-Up
- Quake on an Oscilloscope
- IRC Necromancy
- Why Does man print "gimme gimme gimme" at 00:30?
- Breaking a Minecraft Economy
- Modern Linux on a 486
- John Carmack - Programming Retreat
- What Happens if you append grep results to the file?
- 50/60 Years of Processor Development
- Norman's Sky
- Fabricating an Integrated Circuit
- StuxNet
- Pranking my Roommate with Targeted Ads
- Playing Battleships over BGP
- 5k 360 Video with John Carmack
- Starting Ycombinator - Jessica Livingston
- Technological Unemployment
- Version Control Before Git with CVS
- A Programmer's Worst Nightmare
- Art in a Database Command
- Raikoth: Laws, Language, and Society
- Five Thousand Years in an Alternate Universe
- An old-timey game dev. hack
- Bitcoin Mining on an Apollo Guidance Computer
- Hexing/Typing/Reversing/Unifying the Technical Interview
- The ZedRipper
- The Infinite Loop that wasn't: a holy grail bug story
- Eight Years at Roblox
- Functorio
- The Cursed Computer Iceberg Meme
- Dissecting a Shader Quine
- Escaping the Dark Forest
- Why is the Nuclear Power Industry Stagnant?
- Ask HN: What are some of the best documentaries you've seen?
- Intro to Computational Astrophotography
- Randar Explanation and Information
- Riven
- On the origins of DS_store
- Twenty years of Valgrind
- "We ran out of columns" - The best, worst codebase
- Phased Array Microphone
- Engineering Sleep
- A Story About ‘Magic'