Anatomy of a LUT: Memory Instead of Math

A LUT is the oldest trick in applied mathematics: if a function is expensive, tabulate it. Napier's 1614 logarithm tables are LUTs; so were the books of precomputed sines navigators steered by. The trade is always the same: memory for speed, plus interpolation between the printed rows. Nothing about that changed when the table moved from paper to silicon; a modern LUT box is a table of 35,937 rows consulted 500 million times a second.

The reason LUTs conquered video specifically: color transforms must run per pixel, per frame, in real time, and the honest math (log decoding, matrix, tone curve, gamut mapping) is a dozen operations deep. One memory fetch plus a tetrahedral blend does it in constant time, the same speed for a simple gamma as for a full film-stock simulation. That constant-time property is why a $2,000 box can apply a transform it took a laboratory to measure.

No one person invented the color LUT; three industries invented it independently. Print (1970s): drum-scanner makers needed scanner RGB → CMYK ink conversion in hardware; Takashi Sakamoto at Dai Nippon Screen filed the tetrahedral-interpolation patents (late 1970s) that still define how 3D LUTs are evaluated today. Computer graphics (1973): Richard Shoup's SuperPaint framebuffer at Xerox PARC used a color-map LUT (8-bit index in, RGB out), the ancestor of every palette, and of the 1D gamma LUT in every GPU since.

Film (1990s): Kodak's Cineon system (1993) digitized negatives as 10-bit log printing density and shipped 1D LUTs to preview them on CRTs. When full digital intermediate arrived ("O Brother, Where Art Thou?", 2000), preview needed the whole nonlinear film chain (negative, print stock, projector) in real time, and only a 3D table could hold it. FilmLight's Truelight (2002) made that a product: measure the lab with a probe, bake it into a cube, trust the monitor. Modern grading inherited all three lines at once.

A 1D LUT is three independent curves: R's output depends only on R's input. That handles gamma, contrast, lift/gain, channel balance, anything separable, in a few kilobytes. What it can never do is let one channel see another: saturation, hue rotation, gamut mapping, and selective color ("warm the skin, leave the sky") all require crosstalk. Load the 1D CURVES chip and note the cube only slides along its own axes; the lattice never shears.

A 3D LUT indexes on the full RGB triplet, so any input color can go anywhere: full volumetric control, including the panel-specific channel interactions no gamma-and-matrix model can capture. That is precisely why display calibration graduated from 1D greyscale LUTs to 3D cubes, and why a 33-point 3D LUT is the standard fix for HDR and wide-gamut monitors. The cost: entries grow as N³, and accuracy now depends on the interpolator.

A 10-bit signal has 1024³ ≈ 1.07 billion possible colors; a 33³ LUT stores 35,937 answers, one per thirty thousand colors. It works because real transforms are smooth: between lattice points, linear interpolation is accurate to the transform's curvature, and curvature shrinks with the square of lattice spacing. Doubling N cuts interpolation error roughly 4×. In practice 17³ carries SDR conversions, 33³ is the professional standard (and the working requirement for HDR's steep PQ curve), 65³ is for camera-native transforms with violent curvature.

The failure mode isn't size, it's placement. Feed a LUT scene-linear data and the first lattice step spans eight stops of shadow detail; no interpolator survives that. The fix is the shaper: a cheap 1D LUT that bends the input into a perceptually even domain (log) so the 3D lattice lands where the eye needs density. Every serious pipeline (a LUT box's 1D→3D→1D node chain, ACES CLF) is shapers wrapped around a cube.

Between lattice points the device must guess. Trilinear blends the 8 corners of the surrounding cell: simple, but the guess for a neutral gray mixes in eight corners that are anything but neutral, so near-neutrals can pick up a cast. Tetrahedral (Sakamoto's method) splits each cell into six tetrahedra and blends only the 4 vertices of the one containing the color; and because the cell's main diagonal is an edge of every tetrahedron, grays are computed from gray-adjacent data. Neutrals stay neutral.

That is why spec sheets bother to say it: AJA's ColorBox, Resolve's 3D LUT node, and every calibration-grade device advertise tetrahedral interpolation. On a 33³ conversion the two differ by fractions of a code value in the flats, but a grade pushed through a small or aggressive cube shows trilinear's cast in exactly the place clients look first: skin and neutral walls. If a cheap box renders your neutrals green, suspect the interpolator before the LUT.

Every LUT in the field is doing one of three jobs, and confusing them causes real damage. Technical / conversion: defined by standards bodies and manufacturers, log-to-display, SDR↔HDR, colorspace to colorspace. Correct by definition; never season to taste. Creative / look: someone's aesthetic opinion frozen into a cube, film emulations, show LUTs, the teal-and-orange chip above. Input-specific: a look built for LogC applied to Rec. 709 is wrong by construction.

Calibration: the inverse of a display's measured error, built by profiling software from probe data, unique to one panel on one day. It belongs in the last box before the glass and nowhere else. The classic on-set disaster is stacking these wrong, a look LUT applied twice, a calibration cube baked into dailies, a conversion missing entirely. The chain discipline (which cube, which order, which device) is most of what the sequel module is about.

The data is always the same grid; the wrappers multiplied anyway. .cube, born at IRIDAS, inherited by Adobe and Blackmagic, now the de-facto interchange format; plain text, blue-fastest ordering, optional DOMAIN_MIN/MAX. .3dl, Discreet/Autodesk lineage (Lustre, Flame), integer output values. .spi3d, Sony Pictures Imageworks, common in VFX via OpenColorIO. Plus a long tail of device-native formats every box vendor maintains.

The Academy's answer to the zoo is CLF, the Common LUT Format: XML that can carry a whole processing chain (1D shapers, matrices, 3D cubes, ranges) in one file with defined precision, plus Autodesk's closely related .ctf. High-end boxes now ingest CLF directly, which matters, because a chain in one file can't be stacked in the wrong order by a tired operator at 2 a.m.

Count the cubes between a lens and an audience: in-camera monitoring LUTs in the viewfinder; a DIT cart's LUT boxes feeding on-set monitors their look plus their calibration; dailies rendered through the same cube; the grading suite's conversion and print-emulation nodes; the reference monitor's internal 33³ calibration; the broadcast truck converting one HDR master to SDR outputs in real time; the LED-wall processor on a virtual-production stage; and the GPU shader in every streaming device applying tone mapping. A single frame can pass through six look-up tables before anyone sees it.

Each of those is a physical device with a load slot, a size limit, an interpolator, and a way to be wrong. The sequel module, LUT Hardware & Workflows, walks that chain box by box: dedicated processors like AJA's ColorBox, DIT-cart staples, live-event processors like Analog Way's LivePremier, and the software that fills them: Livegrade on set, Resolve in the suite, Calman and ColourSpace for the calibration cubes. If it isn't measured, it isn't calibrated.