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. 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

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 lane means the look is compared against an unchanged signal, which describes the raw transform. Putting the camera's own standard render in the reference lane instead is usually what you want, because then the report describes only what your look adds on top of the manufacturer's image rather than re-describing the manufacturer's image every time.

Input encoding, output and data levels

Each lane starts with its input encoding: the signal the chain expects to be fed, such as ARRI LogC4 or Sony S-Log3. Below the lanes, output display sets what the finished signal is read as, and data levels states whether that signal is full range or legal range. These three are assumptions, not measurements, and everything downstream rests on them, so they are stated plainly rather than guessed at.

Under the input encoding, lutspeak checks your declaration against the file's own behaviour. It can only ever contradict a choice, never confirm one, because where a render puts mid grey is the render's decision. When it says nothing, nothing is wrong.

The chain

Nodes run left to right. The signal enters at the input encoding, passes through each node in turn, and leaves as the output. Between every pair of cards there is a small plus that inserts a node at that exact point, and the tool bar under each lane does the same thing at the end of the chain.

Working a chain

Every card carries the same set of controls in its header:

• The switch bypasses the node. It keeps its place in the chain and contributes nothing, which is how you A and B one node without losing where it sat.
• ? opens the node reference: what this node is for, what it expects to be handed, what it hands on, and the caveat worth knowing before placing it. Every node in the app is listed, so it doubles as the catalogue.
• The reset arrow returns the node to the settings it was created with. It 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.
• The chevron folds the card down to one line stating what it is set to.
• Duplicate, the arrows, and the cross copy the node, move it along the chain, and remove it.

Cards can also be dragged into a new position. Undo and redo cover everything, including deletions and lane copies.

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.

Copying a lane

Each lane header has a button that replaces the other lane with a copy of itself, input encoding included. This 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 against the reference, so in the reference lane it would tap the thing being measured. An image viewer holds a loaded still and would open a second window over the first. 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 file you can archive or send to someone; 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 tool bar 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.
• Tone shape is film-style contrast: a smooth curve set by its toe, pivot and shoulder, with black and white pinned where they were.
• 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.
• 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 shows your own still, rendered live through the chain up to that point, in a floating window you can move and resize.

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. Leave the window open while you refine the nodes above; it re-renders as you work.
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. Press copy to reference lane. The reference 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 card tells you which one the position has made.
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. Move the window where you can see it and work on the other cards. It re-renders as you edit.
4. Insert a second viewer earlier in the chain for 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 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 chain and between controls, left and right to move card to card.
• Alt with left or right moves the focused node along the chain.
• Enter folds or unfolds the focused node, i inserts at it, Escape closes a picker.
• Command or Control with Z undoes, with Shift redoes.
• ? 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.