How GPUs turn
math into pixels.

The problem: 124 million little jobs

Every pixel on your screen needs a color, computed from scratch, every single frame. Do the math on a plain 1080p monitor and the number gets silly fast. A single brilliant worker won't cut it — no matter how fast it is.

One genius vs two million interns

Same picture, two strategies. The CPU is a genius: it paints one cell at a time, blisteringly fast, in order. The GPU hires a patient little worker for every cell and tells them all "go" at once. Each cell's color doesn't depend on any other cell — so nobody has to wait. Watch who finishes.

and remember — this toy grid is 1,296 cells. your real screen is 1,600× bigger.

Rasterization: the coverage test

Every 3D model — every dragon, every face, every blade of grass — is just triangles. The GPU's job is to figure out which screen pixels each triangle covers, then color them. Step through the stages below. Drag the vertices. The key thing to notice: every cell runs the exact same test, independently — which is exactly why parallel wins.

An actual vertex shader

This is not pseudocode. This is GLSL — the language shipped to your graphics card by every OpenGL game. One tiny program, and the GPU runs it for every vertex of every model, simultaneously. Look at the line that matters: it's the matrix multiply from chapter 03, verbatim.

#version 460 core
layout (location = 0) in vec4 aPosition;
uniform mat4 uModelMatrix;
uniform mat4 uViewMatrix;
uniform mat4 uProjectionMatrix;
void main(void)
{
    gl_Position = uProjectionMatrix * uViewMatrix * uModelMatrix * aPosition;
}

Forgot what uProjectionMatrix * uViewMatrix * uModelMatrix actually does to a point? That whole pipeline is chapter 03 — matrices.