lutspeak pro manual

Professional mode builds and describes chains. Where the simple app reads one file and tells you what it does, pro mode lets you stack LUTs, grades, conversions and creative tools in order, measure the result at any point, and write it back out as a file. Everything still runs in your browser and no file you open is ever uploaded.

It needs a desktop or a landscape tablet, 1024 pixels across at the least. If you only want to know what a LUT does, the simple app is faster and says the same things.

How the page is arranged

A strip across the top holds the chain, and four panels below it hold the work. The page itself never scrolls: the interface fills the window, and a panel scrolls its own content only when that content genuinely exceeds it, with a hairline under its header saying so.

It needs width. Four panels appear from 1280 pixels across, two from 1024, and below that the simple app is the better tool and this mode says so rather than cramping itself.

The strip: the chain as tiles

Each node is a tile carrying the picture at that point in the chain, its number and its name, reading left to right in signal order. This is the quickest thing in the interface: a row of thumbnails shows where the picture actually changes, so one node doing all the work, or nothing at all, is visible without opening anything.

The dot on a tile is both the bypass switch and the state. Filled means the node is in the chain; hollow means it is bypassed, contributing nothing while keeping its place. Click a tile to select it and its settings appear in whichever panel is set to Node settings.

The chips at the left are each lane's input encoding, where the signal enters, and the chip at the right is the output display and data levels. Beside the encoding, copy to reference replaces the other lane with a copy of this one, which is how a comparison of two versions of the same chain starts; it says what it left behind, because a readout, an image viewer and a match trim cannot travel. An encoding chip marked with a question mark is one the chain itself contradicts: hover it for what the measurement found.

The connectors between tiles are insertion points: click one, or the plus at the end, to open the palette. The palette holds every node this app can insert, grouped by what it does, and it marks what your chosen position would make of each one, refusing outright the ones that could mean nothing there.

Under the strip, one sentence states what is being measured: which file, at which point, against what, through which output. It is the most important line in the interface, because a report that does not name its subject can change subject without anyone noticing.

The reference chain is folded away, since that sentence already names it. The toggle beside the sentence opens it as a second row of tiles when you want to work on it.

The panels

Each panel has one menu naming what it shows and a control that fills the window with it and gives it back. Any panel can take any role:

• Image viewer: your own still, rendered live through the chain up to the position of the image viewer node it is showing. With more than one, a second menu chooses which.
• Node settings: the selected node's controls. On a wide panel these lay out in two or three columns rather than one tall stack.
• Analysis: one instrument, chosen in the header. The Description is among them, because it is an instrument like the rest.
• The chain: every node listed with what it is set to, for when the strip is not enough.
• Output: output display and data levels.

Two panels may hold the same role with different subjects, which is the point of the arrangement. Two Image viewers on the same still at two points of the chain is a live before and after with no windows to manage. Two Analyses is the Description beside the Tone curve.

Floating windows

The control beside each panel's menus opens what that panel is showing in a floating window: the same menus, the same content, in a window you can drag by its header and resize from its corner. It is a copy rather than a move, so the panel keeps its place and the window is a fifth thing on screen. Up to three at once, they remember where you left them, and each one holds its own instrument settings, so a window can sit at 12-bit while the panel beside it reads 8-bit, or hold the wipe while the panel shows false colour.

One rule the interface keeps for you: the picture and an analysis are always both on screen. Set the last panel holding one of them to something else and another panel takes over the role rather than letting it disappear. Filling the window with a single panel suspends that deliberately, because that is you asking for one thing at full size.

Drag the boundaries between panels to resize them, or focus one and use the arrow keys. Your arrangement is remembered on this machine and is not part of the document: a .json sent to a colleague describes a chain and does not rearrange their screen.

The two lanes

The look lane is the chain being described. The reference lane is what it is judged against. Every number in the report is a comparison between the two, so the reference is not decoration: it decides what the words mean. An empty reference means the look is compared against an unchanged signal, which describes the raw transform; putting the camera's own standard render there instead makes the report describe only what your look adds on top of it.

Input encoding, output and data levels

The input encoding is the signal a lane expects to be fed, such as ARRI LogC4 or Sony S-Log3. Output display sets what the finished signal is read as, and data levels states whether that signal is full or legal range. These three are assumptions, not measurements, and everything downstream rests on them, so they are stated plainly rather than guessed at. lutspeak checks your declaration against the file's own behaviour and speaks up when the two contradict. It can only ever contradict a choice, never confirm one, because where a render puts mid grey is the render's decision.

Working

Numbers

Every numeric field can be dragged as well as typed. Drag right or up to increase, left or down to decrease; hold Shift for coarse movement. A field with a stated range crosses it in about one screen width of travel. Click without moving and the field behaves as it always did, ready for typing.

A node's own controls

A node's card, in the Node settings panel, carries its bypass, a ? opening the node reference, a reset arrow returning it to the settings it was created with, duplicate, the arrows that move it along the chain, and the cross that removes it. The reset appears on any node with more than one setting, and not on a LUT file or an image viewer, because those hold loaded content rather than settings.

Copying a lane

Each lane can be copied onto the other, input encoding included, which is how a comparison between two versions of one chain starts: copy across, then change one thing. Three kinds of node stay behind, and the app says which it left. A readout describes the look lane, so in the reference lane it would tap the thing being measured. An image viewer would open a second view of a picture already on screen. A match trim in the reference lane would ask the target to chase itself.

Saving

Your work is kept in the browser and comes back when you return, including loaded files and images. Save writes the whole document out as a .json you can archive or send; open reads one back. Notes downloads a written record of the session: the chain node by node, what it measures, and what it claims, in markdown.

The nodes

The palette groups nodes by what they do to the thing being described. The in-app ? gives each one's full entry; this is the map.

Compose: the chain is still your look

• LUT file applies a .cube, .3dl, .alf4, .alf4c, .aml or .l16 from disk. One slot can hold several cuts of the same look and switch between them, stating how far apart they measure.
• Standard render loads the camera manufacturer's own display render from the bundled library. These are the vendors' actual files, not imitations.
• CDL is an ASC CDL: slope, offset and power per channel, then saturation.
• Transfer conversion changes the encoding, for example S-Log3 to Rec.709. It changes the container, not the look.
• Data levels remaps legal range onto full range or the reverse. This is the only node meant to move black and white.
• Repair mends defects inside a loaded file: reversals, noise, values out of range. It never invents detail, and says what it could not fix.
• Match trim solves a CDL that pulls the look lane toward the reference lane, at its own position in the chain.
• Intensity blends everything before it against no chain at all, so a look can be dialled back.
• Split tone tints shadows one way and highlights another, dialled in vectorscope degrees. The tint carries no brightness, so only colour moves.
• Hue warp moves each hue family's hue and saturation independently, holding lightness and protecting greys.
• Printer lights trim each channel's exposure in the unit a lab times a print in: twelve lights to a stop, so a point is a twelfth of one. The trim is applied in light rather than in code, which is what separates it from a CDL slope: one light is a different number of code values in the shadows than in the highlights, and the same amount of exposure in both. Black stays black.
• Tone shape is film-style contrast: a smooth curve set by its toe, pivot and shoulder, with black and white pinned where they were. Hand the dials to the curve and you can place points yourself, pin the slope through one, break it into a corner with a different slope on each side, or hold it flat for a plateau. None of them can fold the curve back on itself. Dragging a point pulls it to the landmarks that matter, mid grey and a 90% white card where this encoding puts them, plus the whole stops or the decades; the readout names whatever it caught. Hold Alt to place a point between them, Shift to move a point along one axis without touching the other. Several points can be taken at once, with Command or Control clicking each one or sweeping a box over them: they then move as a body, keeping their spacing exactly, and a spread figure steepens or flattens their outputs about their own middle. Any channel that differs from the master is drawn behind it in its own colour, as the node bakes it, so a print-like split is something you see rather than something you find by changing tabs, and the readout gives the three values and the split between them at the cursor. Mark keeps the shape you have now drawn faintly behind everything you do next, so a change is a comparison rather than a memory, and reference draws what the reference chain does to a grey ramp, measured through the whole of it. Right-clicking the plot also offers fit to the reference, which solves the curve that makes this look match the reference in tone, through whatever else is in the chain either side of it, and then says how close it got and what stopped it getting closer. It also offers fit to measured values: type what a patch reads at this node and what the chain should put out for it, from a chart on a scope, and the curve that does it is solved through everything else in the chain. Right-clicking a point offers its kind, its slope pin and its removal without crossing the card, and right-clicking the plot offers the shapes worth starting from: a film toe, a rolled shoulder, a filmic S, a flatten, and straight. A preset applies in whichever domain the curve is being edited in, so a toe dialled in stops is a toe in stops. Moving the cursor along the curve lights up the tones under it in any still on screen, and says how much of the frame is at that tone. The light is a tenth of a stop either side, and where the picture is being shown further down the chain than the curve is being edited, the band is carried there through the nodes between on a grey, so it is exact for neutrals and close for colour. With room to show it, the card also states the look's exposure latitude: the gamma in light at mid grey, which is the photographic contrast the look renders, and how far the exposure can be out before that gamma changes character. A look built in log holds across most of what its container carries; a display-referred one often holds a tenth of a stop, which is why grading happens in log. The slope plot is read against the depth the deliverable is cut at: a slope of 4 turns one input code into four output ones, which is visible at 10 bits, four times coarser at 8 and four times finer at 12, so cut at moves the line the shape is judged against and the figure beside it says how much of that budget the curve is spending. While a point is being dragged the line under the plot states the move itself: how far in and out, the same move in stops of light, and what it did to the contrast either side of the point.
• True black and white gives the chain's output the reach a deliverable expects. It measures where the response actually ends, the floor and ceiling of its neutral output, and either scales the whole range to the anchors or smoothly extends the last reach of it, leaving everything above a knee untouched. Both fixes travel along the look's own colour: the shadow cast rides down to black on one luma factor instead of bleaching channel by channel, and a warm highlight keeps its hue on the way to white by desaturating rather than letting each channel arrive at its own rate. A crushed flat run moves to true black but stays flat, and the card says so: gradation the chain discarded cannot be invented. This is the floor adjustment the description asks for whenever it says a look never reaches true black.
• Skin protect holds, warms, cools or porcelains skintones while the rest of the look moves. The mask is a measured fact rather than a picker: in Oklab, every complexion from very light to dark shares three degrees of hue, and the saturation of skin (chroma over lightness) is the same at any exposure, so the mask needs no exposure logic and a frame that is a stop out masks identically. Protect returns skin toward what the lane takes in, along a path that never desaturates below either end; its meaning depends on where the node sits, protecting from whatever is before it. Warm and cool ride the same temperature axis the report measures casts on, scaled so one number is the same visible change on every complexion, and tilt slides any action toward the light or the deep end of the complexion range. Terracotta and copper are the same pigment chemistry as skin and are caught partially; the lightness window is the tool for a wood-panelled room.
• Interlayer is film's inter-image effect: each colour layer suppresses the others in proportion to its own development, so colours purify by competing. Greys cannot move.
• Process is the Process Lab: five historical colour processes modelled as one physical machine.

Derive: the chain is replaced by something computed from it

These five change the subject. What follows them describes the derived thing, not the original, and the report says so.

• Monochrome collapses colour to grey by stated luma weights, isolates a single channel, or renders a saturation map: the grey answers how much colour is here rather than how much light, neutrals black, a primary white, unchanged by exposure.
• Reverse inverts the chain before it, so a render can be undone.
• Isolate keeps only the colour half or only the contrast half of the chain before it.
• Mix curves rebuilds the chain from its own per-channel curves, remixed as you choose. Curves cannot carry cross-channel colour, so anything the chain did between channels is dropped here by construction.
• Fit CDL condenses the chain before it into ten numbers, and states how far the fit lands from the original.

Read: taps that change nothing

• Readout describes the chain at its exact position. Nodes after it are invisible to its reading, which is the point of being able to place it.
• Image viewer marks a point in the chain to look at. Point any panel's Image viewer role at it and you see your own still rendered live through the chain up to there; two of them, in two panels, is a live before and after.

Deliver

• Export writes the chain up to its position out as a cube or an ASC CDL. Nodes after it are not in the file it writes.

Where a node can go

Position is part of a node's meaning, so the app has an opinion about it. When you open an insert point, each tool in the palette is marked:

• Fine. The node can do what its name says here.
• Changed meaning. It will work and mean something, but something other than what its name suggests, and the card says what the position has turned it into. A CDL after a display render is a legitimate thing to ask for; it is simply not the same as a CDL before one.
• Refused. There is no coherent reading, so the palette will not insert it and says why. A reverse with nothing in front of it has nothing to undo.

Refusal is kept narrow on purpose. A tool that forbids what it merely disapproves of teaches you to fight it.

Worked examples

1. Describe a LUT someone sent you

The fastest useful thing pro mode does, and the shape every other workflow starts from.

1. Set the look lane's input encoding to the camera log the LUT expects.
2. Insert a LUT file node and load the file.
3. In the reference lane, insert a Standard render and pick the same camera's official render.
4. Read the verdict at the bottom. It now describes what the LUT adds on top of the manufacturer's image, rather than describing the manufacturer's image over again.

If the description reads strangely, check the input encoding first. Reading a LUT through the wrong log measures the wrong points on its curve and every number after that is wrong.

2. Build a look and deliver it as a cube

Order matters here more than anything else on this page. The creative nodes are built to sit after a render, working on the image you will actually see.

1. Look lane input encoding: your camera log. Insert a Standard render as the first node, so everything after it is working on a display image.
2. Insert Tone shape and set the contrast, then the toe and shoulder. Black and white stay put, so nothing you do here crushes or clips.
3. Insert Split tone for the shadow and highlight colours. The wheel is in vectorscope degrees, so a lean read off a scope types straight in.
4. Insert Hue warp to fix whatever the tone move did to a specific family, most often skin or foliage.
5. Insert an Image viewer at the end and load a still from the shoot. Set a panel to Image viewer and it re-renders as you refine the nodes above.
6. Insert Intensity at the end if the whole look wants dialling back as one thing.
7. Insert Export, choose a 33 or 65 cube, and download. The dialog measures what each size costs against this particular chain rather than in general.

Put a Readout just before the export if you want the finished look described in words before you send it.

3. Compare two versions of a show LUT

The question is never "what does v4 do", it is "what did v4 change".

1. Build the chain once in the look lane, with a LUT file node holding v3.
2. Copy the look lane onto the reference. It is now identical, encoding and all.
3. In the look lane's file node, press + version to compare and load v4, then switch to it.
4. The verdict now describes only the difference. When the two measure close it says so plainly instead of inventing a grade, and "show numbers" carries the largest difference found anywhere.

The same trick answers "does my new grade survive the show LUT": copy across, then add your grade to the look lane only.

4. Match a second camera to your A camera

1. Look lane: the B camera's input encoding, then its Standard render.
2. Reference lane: the A camera's input encoding, then its Standard render.
3. In the look lane, insert a Match trim before the render if you want the correction a DIT would dial into the camera, or after it for a correction applied to a finished image. The palette marks what the position makes of it, and the card says so too.
4. Read how close the solved trim gets. A CDL has ten numbers and cannot do everything, so the honest statement of what it could not reach is part of the answer.
5. Insert Export set to ASC CDL, which is lossless exactly when the chain up to that point already is one.

5. A film-process look, honestly

1. Build to a display image first: input encoding, then Standard render. The Process and Interlayer nodes decode to light, so they belong after a render, not on raw log.
2. Insert Process and choose a stock. Three-strip Technicolor and Kodachrome are the most useful starting points; two-colour and Dufaycolor are strong period effects.
3. Use strength to sit the process where you want it. At 0 it is the identity, which is the honest control.
4. Optionally print one stock's records through another stock's dyes, or drag the dye bands along the spectrum. These are physically coherent looks that never existed.
5. Add Interlayer after it for the layer competition that makes film saturation behave differently from a saturation dial. Start at Modern negative and raise the strength.
6. Read the provenance line on the Process card before you use the result anywhere it matters. The dyes are modelled from each process's documented behaviour, not scanned from surviving stock.

6. Check the whole thing on your own frame

1. Insert an Image viewer anywhere in either lane and load a TIFF, PNG or JPEG. 16-bit TIFFs keep their full depth.
2. Set file is to the colour space the file actually is. If you declare it wrongly, the card measures the pixels and tells you: a log export declared as a display image renders far too dark, and lutspeak says so with the numbers.
3. Work on the other panels. The picture re-renders as you edit.
4. Insert a second Image viewer earlier in the chain and set another panel to it: two panels, two points of the chain, a live before and after side by side.

7. Repair a file that misbehaves

1. Load the file into a LUT file node.
2. Insert Repair directly after it, before anything that rebuilds the chain. Repair fixes what a file contains, so it needs to be looking at the file.
3. Read what it found and what it could not fix. Where a file has thrown information away, the repair says so rather than guessing.
4. Insert Export to write the mended version out.

Delivering

The export dialog prices each format against your actual chain rather than in general:

• A 3D cube holds everything the chain does, to the accuracy of the grid size you pick. The dialog measures the error at each candidate size so you can choose against this chain instead of out of habit.
• 1D curves hold only what a separable chain has. If your chain moves colour between channels, that is lost, and the dialog states how much before you commit.
• An ASC CDL is lossless exactly when the chain up to that point already is a CDL, and otherwise a fit whose distance from the original is measured and stated.

What "shown as" means on your screen

When the output is a display encoding, such as Rec.709 or sRGB, its code values go to your screen as themselves and your screen's own transfer presents them. That is what the ARRI Reference Tool, Resolve's viewer and QuickTime all do, so a Rec.709 render looks the same here as it does there.

It is worth knowing why that is the right choice rather than the lazy one. Rec.709 is mastered on a 2.4 gamma display in a dim room, and sRGB's shallower gamma exists for brighter rooms; that difference is the surround compensation, not an error. Converting between them to preserve absolute light cancels the compensation out and leaves the picture too dark for the room you are actually in, by eight to thirteen code values in the mid-tones, with the deepest shadows crushed to black. When the output is log or HDR instead, a conversion is unavoidable, because those code values would be unviewable as they stand, and the words "shown as" are the app saying so.

What it cannot do

Everything here is a LUT, mathematically: one pixel's colour in, one colour out. That is a real boundary and worth knowing.

• Nothing that depends on a pixel's neighbours: no grain, no halation or glow, no sharpening, no vignette.
• No spatial texture from a film process, such as the mosaic of a colour screen plate.
• Nothing that depends on the shot: no tracking, no keys, no windows.

Within that boundary the app tries never to overstate. Modelled things say they are modelled, fits state their error, and a measurement that could not be made is reported as missing rather than filled in.

The keyboard

• Tab into the strip and between controls, left and right along the chain tile to tile, Home and End to its ends.
• Alt with left or right moves the focused node along the chain.
• Enter opens the focused node in Node settings, i inserts at it, Backspace removes it.
• Arrow keys on a panel boundary resize the panels.
• Command or Control with Z undoes, with Shift redoes. Undo covers everything, including deletions and lane copies.
• ? shows this list in the app.

Page visits are counted anonymously with GoatCounter: no cookies, no IP addresses, and nothing at all about the files you open.