Graphics and Rendering

This section is the wiki's most technically coherent cluster — seventeen articles that fit together like the stages of a rendering pipeline. The unifying theme isn't any single technique but a recurring question: what's the minimum you need to compute in order to produce an image that looks right? The answer keeps changing as hardware evolves, but the strategies — exploit structure, skip empty space, trade accuracy for speed, let the human visual system do the rest — are remarkably stable.

Two Ways to Define Geometry

The deepest architectural divide in graphics is between explicit geometry (triangles, meshes, vertices) and implicit geometry (distance functions, scalar fields, density volumes). Most of the industry runs on triangles, for good historical reasons: they're easy to model, easy to rasterize, and the GPU was built to accelerate them. But implicit surfaces keep returning because they have properties triangles lack — infinite resolution, natural boolean operations, compact representation.

Signed Distance Functions is where the implicit story starts. From Hart's 1989 sphere tracing to Inigo Quilez's Shadertoy masterpieces to Unreal Engine 5's Lumen using SDFs for global illumination, the humble "how far am I from the nearest surface?" query turns out to be one of the most versatile primitives in graphics. Volumetric Rendering extends this to density fields — clouds, smoke, fire — where there's no surface at all, just gradients of opacity that you accumulate along a ray. OpenVDB and NanoVDB provide the sparse data structures that make this practical at scale.

2D Vector Graphics On GPU reveals a surprising irony: 2D graphics are harder than 3D on modern hardware, because the PostScript imaging model demands Bezier curves while GPUs were built for triangles. Raph Levien's Vello project and the broader compute-shader 2D renaissance are trying to close this gap. Anti Aliasing is where the two geometry traditions collide most visibly — the mismatch between continuous curves and discrete pixels is the fundamental sampling problem that every rendering technique must address.

Light Transport

Path Tracing is the mathematically complete approach: solve the rendering equation by shooting rays, bouncing them randomly, and accumulating. Everything — global illumination, caustics, color bleeding, contact shadows — falls out automatically. Physically Based Rendering provides the material models: microfacet BRDFs, energy conservation, the metallic/roughness parameterization that Google's Filament achieves at 60fps on mobile.

Color Science sits underneath all of this and reveals that "correct" has three meanings — physically correct (linear light transport), perceptually correct (Oklab-like uniform spaces), and aesthetically correct (the artist's judgment about what conveys the right feeling). The moonlight discussion is a perfect case: physically, moonlight is near-identical to sunlight. Perceptually, we see it as blue due to rod-cone interactions. A rendering pipeline needs to handle both, plus the artist's choice to grade the final image however it looks best. This connects to Visual Perception As Construction in the Philosophy of Mind section — color isn't in the light; it's a judgment the brain constructs.

The GPU as Machine

GPU Pipeline Architecture explains what the hardware actually does — the life of a triangle from draw call to pixel, the 2x2 quad shading model, why small triangles are catastrophic. Shader Programming covers the languages that target this machine, from HLSL through GLSL to the differentiable turn where NVIDIA's Slang bakes automatic differentiation into the type system. Compute Shaders is what happened when someone looked at thousands of GPU math cores and asked why they should only draw triangles — the three-level hierarchy of work items, work groups, and dispatches that powers everything from physics simulation to prefix sums.

GPU Driven Rendering represents the current frontier: the GPU making its own rendering decisions rather than waiting for the CPU to tell it what to draw. Nanite's visibility buffer, compute-based software rasterization, and GPU-side culling are the concrete implementations. Deferred Shading is the earlier revolution that decoupled geometry from lighting via the G-buffer — now itself being superseded by the visibility buffer approach that decouples geometry from materials entirely.

Constraint as Creativity

Demoscene is the section's secret backbone. The culture of producing audiovisual art in impossibly small executables — 4K intros, 256-byte demos, postcard-sized path tracers — drove the development of techniques that eventually entered production: SDF composition, ray marching, procedural generation. The Oulipo of computing. Fluid Simulation connects through lattice Boltzmann methods compressed to 1KB of JavaScript. Procedural Terrain Generation shows process-based approaches (erosion, flow accumulation, Voronoi meshes) producing terrain that noise alone can't match. Texture Compression is the other side of the constraint story — the random-access requirement that makes GPU texture compression fundamentally harder than image compression.

Animation Principles is the outlier — the only article in the section that's about perception and aesthetics rather than implementation. But its argument that energy matters more than detail connects to every other article: the rendering equation is a description of physics, but the goal is always a description of how physics looks to a human, which is a different and harder problem. Disney's squash-and-stretch and Griffith's Taoist VFX critique both say the same thing: when physical accuracy and perceptual truth conflict, perception wins.

What Connects Outward

The graphics section is the most insular cluster in the wiki, but it has natural bridges to other sections. To Philosophy of Mind through visual perception, color perception, and the constructedness of what we "see." To Simulation through cellular automata (NCA), fluid dynamics (LBM), and procedural generation as emergence. To Hardware through FPGA design, CORDIC, and silicon-level rendering. To AI through differentiable rendering, Gaussian splatting, and the convergence of rendering and machine learning. These bridges exist in some articles already; others are noted but not linked.