Take two colorists. Give them both the exact same .cube file. One applies it in DaVinci Resolve. The other applies it in an older version of Adobe Premiere Pro. They compare the result on a shot with a smooth sky gradient. The colors are close — but not identical. The gradient in Resolve is clean. The one in Premiere shows faint, stepped banding in the transition from deep blue to the horizon.

Neither colorist did anything wrong. The .cube file is not corrupt. The difference is entirely invisible in the file itself — it sits in a single setting that most editors never touch, and that most NLE interfaces do not surface prominently: the interpolation method.

When Adobe introduced tetrahedral interpolation as the default in Premiere Pro 15.0 in early 2021, users on the Adobe Community forums noticed that sky gradients, skin tones, and subtle shadow rolls all improved on complex grades — without changing a single file. Many of them did not know why. The answer is the same algorithm that DaVinci Resolve had been using as its default for years. The improvement was not in the LUT. It was in how the application read the data between the LUT’s stored points.

This article explains what interpolation is, why there are two fundamentally different ways to do it, what the mathematical difference means for the colors in your footage, and exactly what to set in every major NLE to make sure you are getting the most accurate result from every LUT you apply.

What a 3D LUT Is Actually Doing — and Why Interpolation Exists

Everything in this article applies specifically to 3D LUTs — 1D LUTs operate on a single tonal axis and require no three-dimensional interpolation at all. If you are familiar with how 3D LUT grid sizes work, you may want to skip ahead to the next section. If not — a quick foundation here will make everything that follows much clearer. For a full treatment of grid sizes, see our earlier article: Does Grid Size Actually Matter? 33-Point vs. 65-Point LUTs Explained.

A 3D LUT stores color transformation data as a three-dimensional grid of sample points, called nodes. Imagine the entire RGB color space as a physical cube. The Red channel runs along one axis, Green along another, Blue along the third. The LUT divides each of those axes into equally spaced intervals and places a node at every intersection. At each node, the LUT records the answer to one specific question: “if the input pixel has exactly this combination of R, G, and B values, what should the output color be?”

A 33-point LUT divides each axis into 33 intervals, placing nodes at positions 0, 1, 2 … 32 along each dimension. That produces 33 × 33 × 33 = 35,937 nodes — each one a pre-calculated, exact answer. A 65-point LUT does the same with 65 divisions, yielding 274,625 nodes and correspondingly finer coverage of the color space.

35,937 Nodes — 33³ LUT exact answers stored
274,625 Nodes — 65³ LUT exact answers stored
16.8 M 8-bit RGB colors possible input values

The gap between those numbers is the entire reason interpolation​‌​‌ exists. A standard 8-bit video frame contains up to 16,777,216 distinct RGB combinations. A 33-point LUT stores exact answers for only 35,937 of them. For every other color in your footage — the overwhelming majority — the application has no stored answer. It must estimate one, using the surrounding nodes as reference points.

That estimation process is interpolation. The LUT provides the landmarks. The interpolation algorithm determines how the application navigates the space between them. Think of it like a road map: the nodes are cities with known coordinates; interpolation is the rule for plotting a path between any two points that are not themselves cities. A crude rule gives you a rough, angular route. A more sophisticated rule gives you the precise, direct path.

Two fundamentally different algorithms have competed for that role since the 1970s. Both are still in use today. They produce measurably different results from the same data — and understanding why they differ explains everything about when one is preferable to the other.

Trilinear Interpolation: 8 Vertices and a History That Goes Back to 1974

Trilinear interpolation is the older of the two methods and, for decades, the only one widely implemented in commercial color management software. Its logic is a natural extension of how engineers think about three-dimensional grids: if you know the values at all eight corners of a box, the value at any interior point is a weighted average of those corners, where the weights depend on the point’s distance from each face.

A Short History

The earliest published description of trilinear interpolation applied specifically to color look-up tables appears in a 1974 British patent by Pugsley, filed on behalf of the UK printing industry. The problem at the time was ink-color prediction: given a target RGB value, calculate the correct CMYK ink percentages. The solution — sample a pre-computed table of known ink-to-color relationships and interpolate between the stored samples — is structurally identical to how a 3D LUT works in video software today.

By the early 1980s, trilinear interpolation had become the de facto standard in professional scanning and printing pipelines. When digital video began to require real-time color transforms in the 1990s, hardware engineers implemented the same algorithm in silicon, and it became the inherited default in many NLE code bases.

The Geometry

When an input color value falls between LUT nodes — as virtually all colors do — the application identifies the eight nearest nodes: the corners of the smallest sub-cube in the LUT grid that contains the input point. These eight corners are labelled by their position relative to the input: P000 (the lower-left-back corner), P111 (the upper-right-front corner), and the six intermediate corners at every other combination of floor and ceiling values along each axis.

The fractional position of the input color within that sub-cube — how far along the Red, Green, and Blue axes it sits between the floor node and the ceiling node — is expressed as three values: fr, fg, and fb, each between 0 and 1. The output color is then computed as the weighted sum of all eight corner values:

Trilinear — reads all 8 cube vertices
↻ drag to rotate

Input (fr = 0.65, fg = 0.42, fb = 0.22) — T1 tetrahedron.  Lines show weighted contributions from all 8 surrounding nodes.

Trilinear Interpolation — 8-Vertex Weighted Average

Fractional position within sub-cube

fr ∈ [0, 1] fg ∈ [0, 1] fb ∈ [0, 1]

Corner weights

$$\begin{aligned} w_{000} &= \textcolor{#C62828}{(1-f_r)} \cdot \textcolor{#2E7D32}{(1-f_g)} \cdot \textcolor{#1565C0}{(1-f_b)} \\[3pt] w_{100} &= \textcolor{#C62828}{f_r} \cdot \textcolor{#2E7D32}{(1-f_g)} \cdot \textcolor{#1565C0}{(1-f_b)} \\[3pt] w_{010} &= \textcolor{#C62828}{(1-f_r)} \cdot \textcolor{#2E7D32}{f_g} \cdot \textcolor{#1565C0}{(1-f_b)} \\[3pt] w_{110} &= \textcolor{#C62828}{f_r} \cdot \textcolor{#2E7D32}{f_g} \cdot \textcolor{#1565C0}{(1-f_b)} \\[3pt] w_{001} &= \textcolor{#C62828}{(1-f_r)} \cdot \textcolor{#2E7D32}{(1-f_g)} \cdot \textcolor{#1565C0}{f_b} \\[3pt] w_{101} &= \textcolor{#C62828}{f_r} \cdot \textcolor{#2E7D32}{(1-f_g)} \cdot \textcolor{#1565C0}{f_b} \\[3pt] w_{011} &= \textcolor{#C62828}{(1-f_r)} \cdot \textcolor{#2E7D32}{f_g} \cdot \textcolor{#1565C0}{f_b} \\[3pt] w_{111} &= \textcolor{#C62828}{f_r} \cdot \textcolor{#2E7D32}{f_g} \cdot \textcolor{#1565C0}{f_b} \end{aligned}$$

Output

$$\operatorname{Out} = \sum_{\,i,j,k\,\in\,\{0,1\}} w_{ijk} \cdot P_{ijk}$$

Expanded

$$\begin{split} \operatorname{Out} &= w_{000}P_{000} + w_{100}P_{100} + w_{010}P_{010} + w_{110}P_{110} \\ &\quad + w_{001}P_{001} + w_{101}P_{101} + w_{011}P_{011} + w_{111}P_{111} \end{split}$$

Cost per output channel

8LUT reads
7multiplications
7additions
22ops total

Bottleneck: 8 LUT memory reads per output channel

Compare → Tetrahedral: 4 reads · 3 mults · 3 adds (+1 sort step) — 2× fewer memory reads

The Fundamental Problem

The formula is mathematically clean. The problem emerges at the boundary between adjacent sub-cubes. Trilinear interpolation is C0 continuous — the output value is always connected across boundaries, with no jump — but it is not C1 continuous: the gradient of the interpolating function changes direction abruptly the moment an input value crosses from one sub-cube to the next.

In practice, this means a smooth gradient in the input — a sky transitioning from deep blue to pale horizon, a skin tone rolling from highlight to shadow, a gentle vignette — can be rendered smoothly within a single sub-cube, then appear to step or band at the boundary where the application switches to a different set of eight corners. With coarser grids (17-point or 33-point LUTs), these boundaries are wide enough apart that the discontinuity is often visible. With 65-point LUTs the sub-cubes are smaller and the artifact is suppressed, but not eliminated.

Trilinear — Strengths

  • Simple, well-understood algorithm
  • Efficient on CPU (no sorting step)
  • Low gate count — implementable in small FPGA / ASIC
  • Predictable, deterministic behavior
  • Accurate enough with 65-point or larger LUTs

Trilinear — Weaknesses

  • 8 LUT reads per pixel — higher memory bandwidth
  • Not C1 continuous — gradient discontinuity at cube faces
  • Visible banding on smooth gradients with 33-point or smaller LUTs
  • Does not guarantee neutral-axis accuracy
  • Inferior accuracy per LUT grid point vs. tetrahedral

Where is trilinear still appropriate today? It remains the correct choice for in-camera monitoring chips, where silicon area and power are hard constraints and the LUT grid is 65-point or higher, and the content is SDR or near-linear. It is also the fallback mode in many software CPU renderers when a GPU is unavailable, and in embedded real-time pipelines (broadcast monitoring, hardware LUT boxes) where the hardware was designed before tetrahedral support became widespread.

Fact — LUT Interpolation Was a Patent Battleground

1974 — Pugsley files a British patent describing trilinear interpolation for ink-color prediction. The core idea — a 3D table of pre-computed color samples plus a weighted-average fill — is already complete.

1981 — Sakamoto and Itooka at Fuji Photo Film file US Patent 4,275,413, describing a method that subdivides the unit cube into six tetrahedra to achieve fewer LUT reads and smoother output. This is the first patent to use the tetrahedral structure for color interpolation.

1980s–1990s — Xerox, Canon, Kodak, and Ricoh file competing patents on tetrahedral variants and optimisations. Xerox US 5,581,376 explicitly notes that its tetrahedral method “requires retrieval of only four vertex values rather than eight.” Cross-licensing agreements and expired patents eventually resolve the conflicts. By the mid-1990s, tetrahedral interpolation is freely implementable by anyone.

Tetrahedral Interpolation: Six Tetrahedra, Four Vertices, One Key Advantage

Tetrahedral interpolation solves the core weakness of trilinear by changing the geometry of the problem entirely. Instead of estimating a color from all eight corners of a sub-cube, it divides that cube into six tetrahedra — triangular pyramids, each with exactly four vertices — and interpolates within whichever one contains the input color. The result reads fewer data points, produces smoother gradients, and carries one geometric property that trilinear cannot offer.

The Origin

The theoretical foundation for decomposing a unit cube into six congruent tetrahedra by sorting three fractional coordinates was established in applied mathematics before color science adopted it. The first patent applying this principle specifically to color look-up table interpolation was filed in 1981 by Sakamoto and Itooka at Fuji Photo Film and granted as US Patent 4,275,413. The patent’s central claim was that sorting fr, fg, and fb into a single ranked ordering uniquely identifies one tetrahedron, and that a weighted sum of only four vertices within that tetrahedron produces a more accurate and computationally cheaper result than trilinear’s eight-vertex average.

How the Subdivision Works

The algorithm begins identically to trilinear: locate the sub-cube in the LUT grid that contains the input color, then compute the fractional position fr, fg, fb within it. Then, instead of proceeding directly to a weighted average, tetrahedral interpolation sorts these three values to determine which of the six possible orderings applies. Each ordering maps to exactly one tetrahedron. Each tetrahedron traces a path through the sub-cube from its darkest corner to its brightest, visiting exactly two intermediate nodes along the way. The case below — T1, where fr ≥ fg ≥ fb — is the example most commonly cited in literature:

Tetrahedral — 6 tetrahedra, neutral axis shared by all
↻ drag to rotate

Each tetrahedron shares the neutral axis (gold diagonal, P000→P111) as a common edge.  Tetrahedral reads only 4 vertices per lookup.

Tetrahedral Interpolation — T1 Case  ( fr ≥ fg ≥ fb )

Fractional position within sub-cube

fr ∈ [0, 1] fg ∈ [0, 1] fb ∈ [0, 1]

Barycentric weights — 4 vertices only

$$\begin{aligned} w_0 \;(\to P_{000}) &= 1 - \textcolor{#C62828}{f_r} \\[3pt] w_1 \;(\to P_{100}) &= \textcolor{#C62828}{f_r} - \textcolor{#2E7D32}{f_g} \\[3pt] w_2 \;(\to P_{110}) &= \textcolor{#2E7D32}{f_g} - \textcolor{#1565C0}{f_b} \\[3pt] w_3 \;(\to P_{111}) &= \textcolor{#1565C0}{f_b} \end{aligned}$$

Output

$$\operatorname{Out} = w_0\,P_{000} + w_1\,P_{100} + w_2\,P_{110} + w_3\,P_{111}$$

Key property

P000 and P111 are the fixed anchors in every one of the six tetrahedral cases — they are the two endpoints of the neutral axis diagonal.

Cost per output channel

4LUT reads
3multiplications
3additions
+1sort step
10ops total

2× fewer LUT reads than Trilinear — lower memory bandwidth

Compare → Trilinear: 8 reads · 7 mults · 7 adds — 22 ops total, 2× more memory reads

All Six Cases

Every case shares P000 and P111 as fixed anchor vertices. The two intermediate vertices depend on the sorted ordering of fr, fg, fb:

All Six Tetrahedral Cases — Sorted Ordering & Barycentric Weights
Case Condition Path through sub-cube Weights (w0 → w3)
T1 fr ≥ fg ≥ fb P000 → P100 → P110 → P111 1−fr   fr−fg   fg−fb   fb
T2 fr ≥ fb ≥ fg P000 → P100 → P101 → P111 1−fr   fr−fb   fb−fg   fg
T3 fg ≥ fr ≥ fb P000 → P010 → P110 → P111 1−fg   fg−fr   fr−fb   fb
T4 fg ≥ fb ≥ fr P000 → P010 → P011 → P111 1−fg   fg−fb   fb−fr   fr
T5 fb ≥ fr ≥ fg P000 → P001 → P101 → P111 1−fb   fb−fr   fr−fg   fg
T6 fb ≥ fg ≥ fr P000 → P001 → P011 → P111 1−fb   fb−fg   fg−fr   fr
Key insight → P000 and P111 appear in all six cases — they are the fixed endpoints of the neutral axis diagonal (R = G = B)

The Neutral Axis

The geometry of the tetrahedral decomposition produces one property​‌​‌ that trilinear cannot replicate. In every one of the six cases above, the two anchor vertices are always P000 and P111. In the RGB cube, these two corners define the neutral axis — the diagonal where R = G = B, and every point on the line is a pure shade of grey. Because this diagonal is a shared edge of all six tetrahedra, any input that lies exactly on the neutral axis is always interpolated using only nodes that also lie on the neutral axis. There is no cross-channel leakage: perfectly neutral grey in produces perfectly neutral grey out, regardless of grid size or the transform stored in the LUT. Trilinear interpolation, operating on a cube with no such guaranteed diagonal, cannot make this promise​‌​‌.

The LUT Analyzer on alestemple.net visualises exactly this property. Its Neutral Axis panel plots the output of every grey input (R = G = B ramp from black to white) against the expected diagonal. A LUT applied with tetrahedral interpolation will show tighter clustering along that line. If you have ever loaded a LUT in the Analyzer and noticed the neutral axis drift metric, now you understand the structural reason it exists: it is measuring the same C0-path guarantee that is either present or absent depending entirely on the interpolation method used to produce the output.

Left: trilinear uses all 8 vertices — including off-axis coloured corners — risking a hue shift on grey tones.

Right: tetrahedral uses only the two axis endpoints; grey is mathematically guaranteed.

Fact — The Secret of the Grey Axis

The RGB cube has a main diagonal running from P000 (0,0,0) = black to P111 (1,1,1) = white. Every point along this diagonal has equal R, G, and B values — it is the geometrical location of all neutral greys in the color space.

In tetrahedral interpolation, this diagonal is the only edge shared by all six tetrahedra. The mathematical consequence: for any input color whose R, G, and B values are equal, the algorithm selects a tetrahedron whose two intermediate vertices lie off the diagonal — but their weights evaluate to exactly zero, because the differences between equal fractional values are zero. The output is determined entirely by P000 and P111.

Trilinear interpolation has no analogous guarantee. On a trilinear path between two off-diagonal corners, rounding and floating-point weighting of non-grey vertices can introduce a faint hue shift into what should be a pure neutral. The effect is measurable on dense log-to-display LUTs applied to footage shot on logarithmic camera profiles.

Tetrahedral — Strengths

  • Only 4 LUT reads — half the memory bandwidth of trilinear
  • Piecewise linear within each tetrahedron — constant gradient, no curvature artefacts
  • Guaranteed neutral-axis accuracy: grey in, grey out
  • Higher accuracy per grid point than trilinear
  • Default in DaVinci Resolve, Premiere Pro 15+, After Effects

Tetrahedral — Weaknesses

  • Requires a sorting step before interpolation
  • More complex to implement in fixed-function hardware
  • Overkill for 65-point LUTs with simple analytical transforms
  • Still C0-only globally: gradient discontinuity exists at tetrahedron boundaries, but is confined to 6 smaller regions per sub-cube — making it far less visible than trilinear’s single discontinuous cube-face transition.

The Performance Paradox: Why Tetrahedral Is Also the Faster Method

The intuitive assumption is straightforward: trilinear is the simpler algorithm, so it must be faster. Tetrahedral adds a sorting step, requires tracking six possible cases, and is described in patents as an “advanced” method. Surely the complexity carries a cost. The assumption is wrong​‌​‌ — and the reason it is wrong reveals something fundamental about how modern hardware actually runs.

Where the Real Cost Lives

On any modern CPU or GPU, floating-point arithmetic is cheap. A multiply-accumulate operation on a GPU shader unit takes a fraction of a nanosecond. A cache miss — having to fetch data from a memory address that is not already in the processor’s local cache — can cost hundreds of times more. The ratio between arithmetic latency and memory latency on current GPU architectures is roughly 1:100 or wider.

LUT interpolation is almost entirely a memory-access problem. The arithmetic (multiplying weights, summing results) is trivial. The bottleneck is fetching the LUT node values from memory. Each unique node lookup that is not already in cache is a potential stall. For a high-resolution timeline with millions of pixels per frame, each extra node read compounds into a measurable throughput penalty.

8 Trilinear reads per pixel, per channel
4 Tetrahedral reads per pixel, per channel
50% Fewer memory reads tetrahedral vs trilinear

The Sort Is Not the Story

The sorting step that tetrahedral requires — ranking fr, fg, and fb to determine which tetrahedron applies — is three comparisons and two conditional assignments. On a GPU shader, this compiles to a handful of min, max, and compare instructions. Against the cost of four LUT texture fetches, the sort is negligible. Against the cost of eight LUT texture fetches, tetrahedral wins on total throughput even after accounting for the sort overhead.

This was not a theoretical observation. Xerox, in the filing for US Patent 5,581,376, made the speed advantage an explicit claim of the invention, noting that the tetrahedral method “requires retrieval of only four vertex values rather than eight” as a primary justification for its superiority over trilinear approaches. The patent was filed in the context of high-throughput document imaging — an environment where processing speed was the primary engineering constraint, not color accuracy.

Fact — The Speed Paradox: Tetrahedral Reads Less Data

The common expectation is that a more accurate algorithm must be slower. For LUT interpolation, this expectation reverses. Trilinear reads 8 LUT nodes per pixel; tetrahedral reads 4 LUT nodes per pixel. On GPU hardware, where memory bandwidth and cache pressure are the dominant performance constraints, halving the number of texture fetches produces a direct throughput improvement.

Xerox US Patent 5,581,376 states the advantage explicitly: the tetrahedral method “requires retrieval of only four vertex values rather than eight.” The patent was filed in the context of document imaging pipelines, where processing speed was the primary design goal — and tetrahedral was the faster choice.

The sort step that tetrahedral requires (three comparisons to rank fr, fg, fb) costs roughly the same as two floating-point multiplications on modern shader hardware — a cost that is recovered many times over by the four fewer memory fetches.

What Peer-Reviewed Science Says: Numbers That Prove the Difference

The difference between the two methods is not merely theoretical. In 2020, Vandenberg and Andriani published a systematic evaluation in the SMPTE Motion Imaging Journal that quantified exactly how large a LUT grid each method needs to achieve perceptually invisible accuracy across different color depths. Their metric was ΔE < 1 — the threshold below which most trained observers cannot detect a color difference under controlled viewing conditions, and the standard accuracy target in professional color management.

The question they asked: if you want ΔE < 1 across the full color volume, what is the smallest LUT grid that each interpolation method can use and still deliver it? The answer differs substantially between trilinear and tetrahedral — and the difference grows larger as color depth increases:

Scenario Accuracy target Trilinear — min. grid Tetrahedral — min. grid Node count reduction
10-bit SDR ΔE < 1 41³  (68,921 nodes) 31³  (29,791 nodes) −57 %
12-bit HDR ΔE < 1 72³  (373,248 nodes) 55³  (166,375 nodes) −55 %
Standard 33‑point LUT — 10‑bit SDR ΔE < 1 Falls short  (needs 41⁺) Meets target  (needs 31⁺) —

Source: Vandenberg, D. & Andriani, P., “Evaluation of LUT Interpolation Methods for Color Processing,” SMPTE Motion Imaging Journal, March 2020.

What This Means for the 33-Point LUT You Already Have

The third row of the table is the one with the most immediate practical consequence. A 33-point LUT is the most widely distributed format: it is the default grid size for virtually every commercially available film emulation, camera LUT, and creative grade package. According to the SMPTE analysis, a 33-point LUT used with trilinear interpolation falls short of the ΔE < 1 threshold for 10-bit SDR content. The grid is not dense enough to compensate for the interpolation method’s C1 discontinuity. In practice, the effective accuracy is closer to what a 28-point trilinear LUT would deliver — a grid 15% coarser than what the file actually stores.

The same 33-point LUT applied with tetrahedral interpolation comfortably meets the ΔE < 1 target, because tetrahedral requires only a 31-point grid to achieve that threshold. The extra two grid points per axis provide headroom. The LUT file is identical; the color accuracy is not. The only variable is the algorithm the application uses to read between the stored nodes.

Practical rule of thumb: a 33-point LUT with trilinear interpolation delivers the effective accuracy of a 28-point LUT. The same file with tetrahedral interpolation delivers its full rated accuracy. If your NLE defaults to trilinear, switching to tetrahedral is the equivalent of upgrading to a denser LUT — at no extra file size cost.

How to Check and Set the Interpolation Method in Your NLE

Most professional NLEs made tetrahedral interpolation the default in the early 2020s, but the setting is exposed differently in each application — and a few still fall back to trilinear under certain rendering conditions. The cards below show exactly where to find and confirm the setting in each major application.

DaVinci Resolve

The interpolation method is a per-project setting found in Project Settings under Color Management. Both Trilinear and Tetrahedral are available; set it once and it applies to all LUTs in that project. Status: configurable per project.

File → Project Settings → Color Management
→ Lookup Tables → 3D lookup table interpolation
→ Tetrahedral

Can be switched to Trilinear in the same panel for comparison or compatibility testing.

Adobe Premiere Pro

Tetrahedral interpolation is applied automatically when the GPU renderer is active (introduced in version 15.0, April 2021). In Premiere 2024+, LUT interpolation can also be set explicitly per sequence in the Lumetri panel. Status: tetrahedral with GPU renderer.

Edit → Project Settings → General
→ Renderer: Mercury Playback Engine GPU Accelerated
(tetrahedral applied automatically when GPU is active)

With the Software Only renderer, Premiere falls back to trilinear. Always confirm the GPU renderer is active after driver updates or Remote Desktop sessions.

Adobe After Effects

After Effects exposes the interpolation method explicitly in the Color tab of Project Settings. Tetrahedral requires GPU acceleration — if Mercury Software Only is active, only Trilinear is available. Status: manual, per-project; GPU required for tetrahedral.

File → Project Settings → Color
→ 3D LUT Interpolation: Tetrahedral (requires GPU acceleration)

Prerequisite: File → Project Settings → Video Rendering and Effects
→ Use: Mercury GPU Acceleration (CUDA / Metal)

With Mercury Software Only, the Tetrahedral option is unavailable — AE uses Trilinear automatically. Check both tabs on every new project.

Final Cut Pro

Final Cut Pro processes LUTs through Apple’s Core Image and Metal shader pipeline. There is no user-accessible interpolation toggle. Status: no direct user choice.

No interpolation setting exposed.
Method determined by Apple GPU driver implementation.

For work where the interpolation method is critical, grade in DaVinci Resolve and round-trip via XML or FCPXML.

Vegas Pro

Vegas Pro does not expose a global LUT interpolation method setting. LUTs are applied through the Video FX chain using OFX plugins — each plugin manages its own interpolation quality internally. Status: per-plugin, no global toggle.

LUT interpolation is controlled by each OFX plugin individually.
Check the plugin’s own settings for quality / interpolation options.
(File → Properties has no LUT interpolation setting.)

Professional OFX plugins that apply LUTs to footage manage interpolation quality internally. Check each plugin's documentation to confirm it uses tetrahedral interpolation rather than a trilinear fallback.

OpenColorIO / CLF Pipelines

In OpenColorIO-based pipelines (Nuke, Houdini, Maya, Blender), LUT interpolation is specified in the config.ocio file or inside a .clf (Common LUT Format) document via the interpolation attribute. Status: per-config or per-CLF node; defaults to linear if unset.

.clf — Common LUT Format (XML)

<ProcessNode type="LUT3D" interpolation="tetrahedral">

config.ocio — OCIO v2+ (YAML)

# Inside a FileTransform or ColorSpaceTransform block:
interpolation: tetrahedral

OCIO v2+ supports both linear (trilinear) and tetrahedral. If your studio config does not specify an interpolation attribute, OCIO defaults to linear. Verify with your pipeline TD if you are working on VFX or animation projects with ACES or custom colour spaces.

Watch for software renderer fallbacks. Several applications silently switch from tetrahedral to trilinear when the GPU renderer is unavailable — for example, during background rendering, Remote Desktop sessions, or on machines with unsupported GPU drivers. If you notice unexpected color shifts after a render, check that the GPU renderer is still active and that the interpolation setting has not been reset by a software update.

Practical Guide: When to Use Tetrahedral, When Trilinear Is Fine

The short answer is: use tetrahedral everywhere your software exposes the choice. The cases where trilinear is actually the correct option are narrow and nearly all involve hardware constraints outside the colorist’s control. The decision grid below draws the line:

Use Tetrahedral

  • DaVinci Resolve, Premiere Pro 15+, After Effects — the setting is there, use it
  • Any 17‑point or 33‑point LUT — coarser grids benefit most from better interpolation
  • Log-to-display transforms (ARRI LogC, S-Log3, Blackmagic RAW (Blackmagic Film color space)) — wide-gamut smooth rolloffs amplify trilinear errors
  • Creative grade LUTs applied to log-encoded footage
  • 10-bit SDR or 12-bit HDR pipelines
  • LUT grid downscaling: converting 65‑point to 33‑point
  • Any workflow where neutral grey accuracy is a deliverable requirement

Trilinear Is Acceptable

  • In-camera LUT monitor chips — fixed silicon, no user choice
  • 65‑point LUTs with simple, near-linear transforms
  • Broadcast hardware LUT boxes and embedded monitoring devices
  • CPU-only software renderers without GPU LUT acceleration
  • Legacy pipeline output matching — replicating the result of an older system that used trilinear
  • Low-stakes preview renders where speed outweighs accuracy

The Log Footage Case

The scenario where the interpolation method has the largest visible impact is log-encoded camera footage with a log-to-display LUT applied. Log encodings like ARRI LogC3, Sony S-Log3, and Blackmagic RAW (Blackmagic Film color space)​‌​‌ concentrate a disproportionate amount of tonal information in the mid-tone and shadow regions of the LUT cube — precisely the area where the transform's slope is steepest. A steeper slope means neighbouring LUT nodes differ more from each other, which amplifies the C1 discontinuity at sub-cube boundaries and makes trilinear banding most visible. A trilinear interpolation path through those regions — where the transform is steep and non-linear — produces the largest C1 discontinuity errors. This is precisely where smooth sky gradients, rolling shadow detail, and subtle skin-tone transitions live. Switching to tetrahedral on log footage is not an academic improvement; it is often visible on an A/B comparison of the same frame.

The 65-Point Exception

A 65-point LUT divides each axis of the RGB cube into 64 intervals instead of 32. The sub-cubes are half the linear size, which means any C1 discontinuity at a sub-cube boundary is also half the magnitude. For simple, near-linear transforms — subtle camera matching grades, gentle contrast curves, desaturation — the trilinear error on a 65-point LUT may fall below perceptual threshold even on demanding content. The SMPTE data confirms this: the 72-point minimum for trilinear at 12-bit HDR is not much larger than 65, and for straightforward transforms the practical threshold is lower. That said, if your application already defaults to tetrahedral, there is no reason to override it for a 65-point LUT. The performance difference is negligible either way.

Key takeaway: the interpolation method matters most when the LUT grid is coarse (17‑ or 33‑point) and the transform is complex (log-to-display, wide-gamut creative grades). In those conditions, tetrahedral delivers accuracy that trilinear cannot match regardless of what the LUT file contains. For 65‑point LUTs with gentle transforms, both methods are acceptable — but tetrahedral still wins on every metric and costs nothing to enable.

When using the alestemple.net LUT Converter to resize a grid — for example, downscaling a 65‑point LUT to a 17‑point format for in-camera use — the interpolation method determines how accurately the output LUT captures the original colour intent. Tetrahedral is the recommended setting for all downscaling operations, and it is the default in the converter precisely because the mathematics described above apply equally to baking a transformation as they do to applying one. The built-in ΔE 2000 quality report will show you the difference numerically: convert the same LUT twice — once with tetrahedral, once with trilinear — compare the ΔE RMS values, and the gap is measurable.

Free Browser Tools

Put Interpolation Theory Into Practice

Two free tools that show you exactly what interpolation does to your LUT — before you commit it to a render.

LUT Format Converter

Convert between .cube, .3dl, .clf and other formats. When downscaling a 65‑point LUT to 33‑point, the converter uses tetrahedral resampling — the only method that preserves neutral-axis accuracy through the downscale.

Open LUT Converter
LUT Analyzer

Inspect any .cube file visually. The Neutral Axis panel plots the P000→P111 diagonal of your LUT and shows whether grey values stay neutral through the transform — the property that tetrahedral interpolation guarantees at the algorithm level.

Open LUT Analyzer

Summary: Tetrahedral vs Trilinear at a Glance

Property Trilinear Tetrahedral
LUT node reads per pixel 8 higher bandwidth 4 50% fewer reads
Arithmetic operations 7 multiplications · 7 additions 3 multiplications · 3 additions + sort lighter
Gradient continuity Variable gradient within sub-cubes discontinuous at cube faces Piecewise linear within tetrahedra constant gradient, smoother
Neutral axis (grey) accuracy Not guaranteed potential hue shift on grey Mathematically guaranteed grey in = grey out
Min. grid for ΔE < 1 — 10-bit SDR 41⁺ (68,921 nodes) 31⁺ (29,791 nodes) −57% nodes
Min. grid for ΔE < 1 — 12-bit HDR 72⁺ (373,248 nodes) 55⁺ (166,375 nodes) −55% nodes
Standard 33‑point LUT accuracy Effective ~28‑point grid headroom lost Full 33‑point all grid resolution used
Visible banding risk High — 33‑point LUTs on log footage stepped gradients visible Low — same LUT, same footage smooth gradients preserved
First documented use 1974 — Pugsley, British patent (CMYK printing) 1981 — Sakamoto & Itooka, US 4,275,413 (Fuji Photo Film)
Hardware implementation Low gate count simple ASIC/FPGA Requires comparator / sort logic moderate
Default in major NLEs Legacy CPU renderers, in-camera chips DaVinci Resolve, Premiere Pro 15+, After Effects industry standard
Best use case 65⁺ LUTs on fixed hardware; CPU-only renderers; legacy matching All software NLEs; 17⁺ or 33⁺ LUTs; log footage; HDR pipelines; LUT downscaling

The data across every axis of comparison points in the same direction​‌​‌. Tetrahedral interpolation reads fewer data points, produces smoother output, guarantees neutral grey accuracy, and requires a smaller LUT grid to hit the same perceptual threshold — all while being faster on GPU hardware due to halved memory fetches. Trilinear has a legitimate role in hardware-constrained pipelines where it was baked into silicon before tetrahedral support was feasible. In any software environment where the choice is exposed, tetrahedral is the correct selection. It is the cheapest accuracy upgrade available: no new files, no larger LUTs, no additional processing time — just a different algorithm reading the data you already have.

Continue Reading

Color Grading Does Grid Size Actually Matter? 33-Point vs. 65-Point LUTs Explained Tutorial How to Analyze a .cube LUT in 60 Seconds — Complete Guide