Lightform FX
Lightform FX
User Guide
Version 1.0 beta  ·  Created by Michael S. Simone
Lightform FX © 2025 Michael S. Simone. All rights reserved.

Contents

1. Introduction

Lightform FX is a node-based visual effects compositor for macOS. You build a flowgraph — a network of processing nodes — that describes exactly how images are combined, colored, tracked, and keyed. Each node takes one or more image inputs and produces a single image output. The final result flows into an Output node which renders the composition to disk.

What you can do

The Node Graph Philosophy

Unlike layer-based compositors, Lightform FX is fully non-destructive: every operation is a node in the graph and nothing is baked until you render. You can rewire, bypass, or remove any node at any time. The evaluation engine caches intermediate results so previews stay fast even on deep graphs.

GPU-Accelerated Rendering

All image processing runs on the GPU via Apple Metal. Full-resolution real-time preview is standard — most operations on HD footage run at interactive frame rates without any proxy resolution required.

2. The Interface

┌─────────────────────────────────────────────────────────────────┐
│  Toolbar: Open · Add · Reorganize · Zoom · Proxy · View         │
├──────────┬──────────────────────────────┬───────────────────────┤
│          │                              │                       │
│  Node    │     Node Graph Canvas        │   Image Preview       │
│ Palette  │   (drag nodes, draw wires)   │   (real-time Metal)   │
│          │                              │                       │
├──────────┴────────────────┬─────────────┴───────────────────────┤
│   Timeline / Scrubber     │   Parameters Panel                  │
│   ◀ ▶  frame counter      │   (controls for selected node)      │
└───────────────────────────┴─────────────────────────────────────┘

Node Palette

The vertical icon rail on the left. Click a category icon to open a flyout panel listing every node in that category, sorted alphabetically. Click a row to drop that node into the graph center. Categories: I/O, Generator, Color, Filter, Channel, Keyer, Transform, Composite, Paint/Roto, Time, Math, 3D.

When you don't remember which category a node lives in, use the search button (magnifying glass) at the top of the rail. It opens a panel with a search field over a combined list of every built-in node and every installed plugin; typing filters live by display name or category, each result shows a muted category tag on the right, Return adds the top match, and Esc closes the panel.

Node Graph

Nodes appear as rectangular tiles. Drag from an output dot (right edge) to an input dot (left edge) to wire them together. The wire snaps when you're close enough. Most nodes expose:

Click a node to select it. Double-click to rename. Delete removes the selected node. Drag the canvas background to pan; pinch or scroll to zoom.

Image Preview

Shows the output of the pinned node (click the pin button in the toolbar) or the currently selected node in real time. Controls:

Preview any point in the graph: every node has a small play icon on its right edge (it's also the output socket you drag wires from). Double-click the play icon to pin that node as the viewer target and start playback — Lightform FX evaluates the full chain of connected nodes feeding into it and shows the result in the preview. Double-click it again to unpin. This is the fastest way to inspect an intermediate stage of a composition without rewiring anything.

Proxy Resolution

When working with 4K or 8K plates on a laptop — or any machine where interactive playback is stuttering — drop the Proxy Resolution toolbar menu (rectangle-with-bars icon, right side of the toolbar) from Full to 1/2, 1/4, or 1/8. Source plates are re-uploaded to the GPU at the reduced size, and every node in the graph evaluates against that smaller pixel count. A ½ proxy is roughly 4× faster per frame; ¼ proxy is roughly 16× faster.

What you see vs. what you render: Proxy Resolution affects only the interactive viewer. When you hit Render Movie or export an image sequence, Lightform FX automatically switches back to full resolution for the duration of the render and then returns to your proxy setting — so your final output always comes from the native source pixels regardless of what you were editing at.

Parameter behavior: Pixel-unit parameters (Transform's Translate X/Y, Blur/Glow Radius, Motion Blur Length, Displace Amount, Camera Shake Amplitude, Light Wrap / Edge Extend Radius, Text Size) automatically scale with the proxy factor so the image looks visually identical across proxy levels. Normalized parameters (Crop edges, Chroma Key tolerance, Levels, blend mix) are resolution-invariant and need no adjustment.

Switching levels: Changing proxy mode clears the source-texture cache and re-uploads at the new scale. Expect a brief pause (usually under a second) the first time you jump to a new level with a given project.

When to stay at Full: Pixel-precise work — roto tracing, corner-pin placement, dustbust inspection, edge-detail keying — benefits from full resolution. Use Proxy while roughing in the chain, then flip back to Full for the detail pass.

Display View & Color Management

Lightform FX is a scene-linear pipeline: every node operates on linear-light pixel values. Source plates that aren't already linear (almost everything except EXR) need to be decoded on the way in; the viewer needs to encode for the monitor on the way out. Two controls drive this:

Display View is viewer-only — it has no effect on rendered output. Pick it independently of how the project will be delivered. L cycles through the common modes (sRGB Display → Cineon Log → Linear). The status bar shows the current view in its compact form (sRGB, Cineon, Rec.709, etc.).

Wipe A/B Comparison

The viewer can split-screen two nodes so you can A/B-compare any two points in the graph in real time — before and after a grade, keyer vs. plate, stabilized vs. original, etc. Unlike a toggle, both sides are rendered live so playback, parameter tweaks, and scrubbing update both halves simultaneously.

The wipe is a viewer-only feature — it has no effect on rendered output. Typical uses: compare your grade against the raw plate by setting the Input node as Wipe A; check a chroma key against the source by setting the greenscreen Input as A and pinning the Blend node; verify a stabilization by setting the original plate as A and the Stabilize node as the preview.

Timeline

Scrub with the slider or arrow keys to navigate frames. The play button (or Space) toggles real-time playback. The frame range is determined by the first connected Input node.

Parameters Panel

When a node is selected, its controls appear in the right panel. Each adjustable value shows:

3. Building a Composition

Step 1 — Import your footage

  1. Choose File → Import Plate… or press ⌘I.
  2. Select your source file. Lightform FX supports image sequences (DPX, EXR, TIFF, PNG, JPEG), single frames, and movie files (MP4, MOV).
  3. An Input node appears in the graph automatically.

You can also drag files or folders from Finder directly onto the graph. Drop a single file to create one Input node at the cursor; drop a folder and Lightform FX reads it as a numbered image sequence; drop several items at once to stack them as separate Input nodes at the drop point.

Repeat for each element in your composition (background plate, greenscreen subject, graphic, etc.).

Step 2 — Build the graph

Drag nodes from the palette and connect them. A typical keyed composite looks like this:

[Input: bg plate] ────────────────────────────────────┐
                                                       ▼
[Input: greenscreen] ──▶ [Chroma Key] ──▶ [Blend: Over] ──▶ [Output]

Connect by dragging from an output dot to an input dot. Wires snap when you're close enough to a socket.

Step 3 — Tune parameters

Click any node to select it. Adjust sliders in the Parameters Panel. Changes apply in real time — the preview updates as you drag.

Step 4 — Render

Choose File → Render Movie… (⌘E), pick a format and destination path, and click Render. The status bar shows per-frame progress.

4. Keyframing

Most numeric parameters can be animated over time using keyframes. The keyframing system uses linear interpolation between keys with hold extrapolation beyond the first and last key.

Setting a keyframe

  1. Scrub the timeline to the frame where you want a specific value.
  2. Adjust the slider or type a value into the readout field.
  3. Click the ◆ button next to that slider. The readout turns orange to indicate a key exists at this frame.

Clearing a keyframe

Click ◆ again at a frame that already has a key to remove it.

How interpolation works

Between two keys, values are linearly interpolated. Before the first key and after the last key, the value is held constant (no extrapolation). All keyframeable parameters are listed with a ✓ in the parameter tables throughout this guide.

Example — animated exposure fade

  1. Select an Exposure node.
  2. At frame 1: set Stops to −4, click ◆.
  3. At frame 30: set Stops to 0, click ◆.
  4. The shot fades from near-black to full exposure over 30 frames.

5. Tracking & Stabilization

Lightform FX includes three tracker types that share a common workflow:

  1. Connect your reference plate to the tracker's BG input.
  2. Set the reference frame and place the feature point(s) on the canvas.
  3. Click Compute Track. The status bar counts frames as it processes.
  4. The tracker sweeps forward from the reference frame, then backward — so picking a mid-shot frame as the reference minimises accumulated drift.

Match Move — 1-Point Tracker

Tracks a single feature using NCC (Normalised Cross-Correlation) template matching. Captures translation only. The tracked offset is applied to the FG input at each frame. At Strength +1 the FG follows the track; at −1 the FG counteracts it (stabilisation).

Best for: Locking a graphic to a simple moving point, or smoothing handheld camera shake.

Two-Point Tracker

Tracks two feature points simultaneously and computes the similarity transform (translation + rotation + uniform scale) between them. More robust than a single point for objects that rotate or zoom.

Best for: Screen replacements where the device tilts and scales, or two-point motion-controlled camera rigs.

Planar Tracker

Tracks a four-corner planar region using the inverse-compositional Lucas-Kanade (IC-LK) algorithm (Baker & Matthews 2004). Solves the full 8-DOF projective homography — not just corner positions, but the complete perspective warp — in a single optimisation per frame. This makes it dramatically more accurate than independent per-corner tracking on surfaces with foreshortening, motion blur, or partial occlusion.

Best for: Sign and screen replacement, corner-pin match moves, any planar surface tracked through perspective changes.

Stabilize

A companion node that reads the transform data from any upstream tracker and applies the inverse of that transform to a connected plate. Unlike using negative Strength on a tracker, the Stabilize node keeps the graph readable by cleanly separating the "what is tracked" node from the "apply stabilisation" node. The Strength parameter blends between stabilised and original to preserve intentional camera movement.

Choosing the right tracker

SituationUse
Simple translation (no rotation, no scale)Match Move
Object that rotates and scales but stays frontalTwo-Point Track
Flat surface with perspective changePlanar Track
Camera shake removalMatch Move + Stabilize

6. Node Reference

Every built-in node is documented below, organized by category. The Keys column in each parameter table indicates whether the parameter can be keyframed over time.

I/O

 Input

Output: RGBA image / sequence

Loads an image, numbered image sequence, or movie file from disk. Supported formats: DPX, EXR, PNG, JPEG, TIFF, QuickTime, MP4, MOV. Frame range is auto-detected from sequence numbering.

ParameterTypeRangeDefaultKeys
Source Path File path — (none) —
Frame Range Int range auto-detected 1 – last —
Source Color Space Enum Scene Linear · sRGB · Cineon Log · Rec.709 · ARRI LogC · Sony S-Log3 · RED Log3G10 · Panasonic V-Log Scene Linear —
Example — Loading a DPX plate

Choose File → Import Plate… or drag a file onto the canvas. Lightform FX detects numbered siblings (e.g. shot_0001.dpx … shot_0240.dpx) and sets the frame range automatically.

Source Color Space is auto-detected on first source-set from format-specific signals: DPX/CIN transfer-characteristic byte, MOV/MP4 colr atom, ICC profile names embedded in PNG/JPEG/TIFF/HEIC. EXR defaults to scene-linear by spec. After the auto-detect lands you can override the dropdown manually — once you do, Lightform stops auto-detecting on later source-set events for that node, so your choice is sticky.

Camera log encodings (ARRI LogC, S-Log3, RED Log3G10, V-Log) delivered as PNG or EXR sequences cannot be auto-detected — the source format strips the camera color metadata. Pick the right space manually for those.

 Output

Inputs: Image · Output: Render to disk

Marks the end of the compositing chain and defines the export format. Connect your final composite here, then choose File → Render Movie… to write the result.

ParameterTypeRangeDefaultKeys
Format Enum Match Input · MP4 · MOV · M4V · Image Sequence Match Input —
Example — Rendering to H.264 MP4

Set Format to MP4, press ⌘E, choose a destination, and click Render. A notification fires when encoding is complete.

Generator

 Checker

Output: Checkerboard pattern

Generates a two-color checkerboard pattern. Used as a test card, UV calibration pattern, or transparency indicator background.

ParameterTypeRangeDefaultKeys
Cell Size (px) Int px 2 – 256 32 —
Color A (RGB) Float×3 0 – 1 each 0.8 grey —
Color B (RGB) Float×3 0 – 1 each 0.1 grey —
Example — Transparency indicator

Color A 0.75 grey, Color B 0.5 grey at Cell Size 16 behind a keyed element makes partial transparency immediately visible without color distraction.

 Constant

Output: Solid RGBA frame

Generates a solid color fill at a specified resolution. Use as a background plate, a matte fill, or a color source for blend and grade operations.

ParameterTypeRangeDefaultKeys
Red Float 0 – 1 0.5 —
Green Float 0 – 1 0.5 —
Blue Float 0 – 1 0.5 —
Alpha Float 0 – 1 1 —
Width Int px 1 – 8192 1920 —
Height Int px 1 – 8192 1080 —
Example — Black background for transparency

Set R/G/B to 0 and Alpha to 1, then connect to the BG input of a Blend node. Use a keyed subject on FG for a clean black-backed composite.

 Fractal Noise

Output: Fractal noise texture

Generates fractal Brownian motion (fBm) noise by summing octaves at increasing frequencies and decreasing amplitudes. Lacunarity controls frequency scaling per octave; Gain controls amplitude falloff. Turbulence mode takes the absolute value for a jagged, cloud-like appearance.

ParameterTypeRangeDefaultKeys
Scale Float 0.01 – 20 2 —
Octaves Int 1 – 8 5 —
Lacunarity Float 1.2 – 3 2 —
Gain Float 0.1 – 0.9 0.5 —
Turbulence Bool on / off false —
Seed Float 0 – 100 1 —
Example — Animated drifting smoke matte

Keyframe Seed from 0 to 10 over the shot length. Set Turbulence on for more energetic, broken-up shapes. Feed through Threshold for a hard smoke boundary or directly into a Blend (Screen) for a softer smoke effect.

 Gradient

Output: RGBA gradient frame

Generates a linear or radial gradient between two RGBA colors. In linear mode the Angle parameter rotates the direction; in radial mode the gradient radiates from the center.

ParameterTypeRangeDefaultKeys
Mode Enum Linear · Radial Linear —
Angle Float ° 0 – 360 0 —
Color A (RGBA) Float×4 0 – 1 each 0, 0, 0, 1 —
Color B (RGBA) Float×4 0 – 1 each 1, 1, 1, 1 —
Width / Height Int px 1 – 8192 1920 × 1080 —
Example — Vignette gradient mask

Set Mode to Radial, Color A to white (center) and Color B to black (edge). Feed the Gradient into the Matte input of a Color Balance node to confine a grade to the frame center.

 Noise

Output: Procedural noise

Generates smooth value noise. Scale controls frequency, Octaves stacks layers of detail, Seed produces a different pattern. Monochrome outputs greyscale; off produces colored noise.

ParameterTypeRangeDefaultKeys
Scale Float 0.01 – 10 1 —
Octaves Int 1 – 6 4 —
Seed Float 0 – 100 1 —
Monochrome Bool on / off true —
Example — Cloud matte

Set Scale 2, Octaves 5. Feed through Threshold to create a cloud-shaped matte, then use it as a Matte input on a Color Balance to add patchy lighting variation to a sky plate.

 Ramp

Output: Gradient ramp

Generates a smooth gradient between two colors in Linear, Radial, or Angular (conical) modes. Curve skews the tonal distribution toward Start or End. More flexible than the built-in Gradient node.

ParameterTypeRangeDefaultKeys
Mode Enum Linear · Radial · Angular Linear —
Angle (°) Float −180 – +180 0 —
Center X Float 0 – 1 0.5 —
Center Y Float 0 – 1 0.5 —
Start Color 0 – 1 each Black —
End Color 0 – 1 each White —
Curve Float 0.1 – 4 1 —
Example — Conical spotlight matte

Set Mode to Angular, Start black, End white, Angle toward the spotlight direction. Use the output as a Matte on an Exposure node to brighten a cone-shaped region, simulating a spotlight sweep.

 Text

Output: Text image

Renders a line of text with a specified system font, size, color, and alignment onto a transparent canvas. Output is an RGBA image for compositing over any background.

ParameterTypeRangeDefaultKeys
Text String any Lightform —
Font Enum System fonts Helvetica —
Size (px) Float 6 – 1024 96 —
Color Color 0 – 1 each White —
Opacity Float 0 – 1 1 —
Center X Float −1 – 2 0.5 —
Center Y Float −1 – 2 0.5 —
Align Enum Left · Center · Right Center —
Canvas Width Int px 16 – 16384 1920 —
Canvas Height Int px 16 – 16384 1080 —
Example — Lower-third title

Type the talent name, set Font Helvetica, Size 72, Color white, Center Y 0.8. Connect to FG of a Blend (Normal) node over the plate. Add a Transform between them to animate a slide-in.

Color

 Brightness / Contrast

Inputs: Image, Matte (optional) · Output: Adjusted image

Adds a brightness offset and scales contrast around the midpoint (0.5). Brightness shifts the overall level up or down; Contrast stretches or compresses the tonal range.

ParameterTypeRangeDefaultKeys
Brightness Float −0.5 – +0.5 0 ✓
Contrast Float 0 – 3 1 ✓
Example — Punching up a flat log-style image

After a Log→Lin node, set Contrast to 1.3 and Brightness to +0.05 for a punchy result while keeping headroom for downstream grading.

 Clamp

Inputs: Image, Matte (optional) · Output: Clamped image

Restricts every pixel channel to the range [Low, High]. Values below Low are raised; values above High are lowered. Insert before export to prevent out-of-gamut values.

ParameterTypeRangeDefaultKeys
Low Float 0 – 1 0 —
High Float 0 – 1 1 —
Example — Preventing super-whites before H.264 encode

Place a Clamp node with High = 1.0 immediately before the Output node to strip any values that would cause banding or macro-block artifacts in the encoder.

 Color Balance

Inputs: Image, Matte (optional) · Output: Color-balanced image

Multiplies the R, G, and B channels independently by per-channel gain values. Use to neutralise color casts, match two plates, or add a deliberate tint.

ParameterTypeRangeDefaultKeys
Red Gain Float 0 – 2 1 ✓
Green Gain Float 0 – 2 1 ✓
Blue Gain Float 0 – 2 1 ✓
Example — Removing a blue cast from LED lighting

Raise Red Gain to 1.05 and lower Blue Gain to 0.92 to warm up footage shot under cool LED panels back to a neutral white balance.

 Curves

Inputs: Image · Output: Curves-adjusted image

Applies a piecewise-linear luminance curve defined by five control points: Black (0), Shadow (0.25), Mid (0.5), Highlight (0.75), and White (1.0). Each output value is independently adjustable.

ParameterTypeRangeDefaultKeys
Black (at 0) Float 0 – 1 0 —
Shadow (at 0.25) Float 0 – 1 0.25 —
Mid (at 0.5) Float 0 – 1 0.5 —
Highlight (at 0.75) Float 0 – 1 0.75 —
White (at 1) Float 0 – 1 1 —
Example — Classic S-curve contrast

Push Shadow down to 0.2 and Highlight up to 0.8, leave others at default. This S-curve increases midtone contrast while softening the extreme ends of the tonal range.

 Exposure

Inputs: Image, Matte (optional) · Output: Exposure-adjusted image

Adjusts image brightness in photographic stops (EV). Each +1 stop doubles luminance; each −1 stop halves it. Computed as output = input × 2stops.

ParameterTypeRangeDefaultKeys
Stops Float −8 – +8 0 ✓
Example — Animated exposure fade-in

At frame 1, keyframe Stops at −4 (nearly black). At frame 24, keyframe Stops at 0. The shot fades from dark to full exposure over one second.

 Gamma

Inputs: Image, Matte (optional) · Output: Gamma-corrected image

Applies a power-curve correction: output = input(1/gamma). Values above 1 lift midtones; values below 1 compress them. Used to linearise monitor-gamma-encoded footage.

ParameterTypeRangeDefaultKeys
Gamma Float 0.1 – 4 1 ✓
Example — Linearising gamma-2.2 footage

If a plate was exported with a 2.2 gamma bake, set Gamma to 2.2 to linearise it before any color math, keying, or compositing operation.

 Grade

Inputs: Image, Matte (optional) · Output: Graded image

A comprehensive single-node color grade with Blackpoint, Whitepoint, Lift, Gain, Multiply, Offset, and Gamma controls — the workhorse node for shot matching and primary grading.

ParameterTypeRangeDefaultKeys
Blackpoint Float −0.5 – +0.5 0 —
Whitepoint Float 0.25 – 4 1 —
Lift Float −1 – +1 0 —
Gain Float 0 – 4 1 —
Multiply Float 0 – 4 1 —
Offset Float −1 – +1 0 —
Gamma Float 0.1 – 4 1 —
Example — Shot matching two cameras

Place a Grade node after each Input. Adjust Lift and Gain to match black and white levels, then Multiply and Offset to align midtone color cast. Gamma trims remaining tonal curve differences.

 HSV

Inputs: Image, Matte (optional) · Output: HSV-adjusted image

Adjusts Hue rotation, Saturation multiplier, and Value (brightness) multiplier in the HSV color model. Hue Shift rotates all hues by a fixed offset in degrees, cycling around the color wheel.

ParameterTypeRangeDefaultKeys
Hue Shift Float ° −180 – +180 0 ✓
Saturation Float 0 – 4 1 ✓
Value Float 0 – 4 1 ✓
Example — Autumn color shift

Set Hue Shift to +40° to push green summer foliage towards amber and yellow for an autumn look without touching skin tones or sky hues.

 Hue Shift

Inputs: Image · Output: Hue-rotated image

Rotates all hues by a fixed number of degrees around the color wheel, leaving luminance and saturation unchanged. A focused single-control alternative to the full HSV node.

ParameterTypeRangeDefaultKeys
Hue Shift Float ° −180 – +180 0 —
Example — Push cyan sky toward blue

Set Hue Shift to +15° to rotate cyan-leaning skies toward a deeper blue. Chain a Saturation at 1.1 to recover any warmth lost in the shift.

 Invert

Inputs: Image, Matte (optional) · Output: Inverted image

Computes 1 − channel for every RGB channel. Alpha is passed through unchanged. Useful for flipping a matte from white-subject to black-subject, or creating photographic negatives.

No adjustable parameters.

Example — Flipping a keyer matte

Connect a Luma Key output to an Invert node to convert a white-on-black subject matte into a holdout (background-selection) matte for use as a second keyer mask.

 Levels

Inputs: Image, Matte (optional) · Output: Levels-adjusted image

Remaps the tonal range by specifying an input black point, white point, and a midtone gamma curve. Equivalent to the Levels tool in Photoshop. Input range is linearly stretched to 0–1 before the gamma curve is applied.

ParameterTypeRangeDefaultKeys
Black Point Float 0 – 0.5 0 ✓
White Point Float 0.5 – 1.5 1 ✓
Gamma Float 0.1 – 4 1 ✓
Example — Crushing blacks and lifting gamma

Set Black Point to 0.05 and Gamma to 0.85 to deepen shadows while keeping midtones rich — a classic starting point for a filmic look.

 Lift Gamma Gain

Inputs: Image · Output: Graded image

Three-control primary color corrector in the broadcast model: Lift adjusts the black point (shadows), Gamma adjusts the midtone curve, Gain scales the white point (highlights). Industry-standard for fast primary grading.

ParameterTypeRangeDefaultKeys
Lift Float −0.5 – +0.5 0 —
Gamma Float 0.25 – 4 1 —
Gain Float 0 – 3 1 —
Example — Quick primary grade

Raise Lift to 0.02 (open shadow detail), Gamma to 0.9 (add contrast), Gain to 1.15 (brighten highlights). This three-move pass is often enough for a complete primary grade on a well-exposed plate.

 Lin → Log

Inputs: Image · Output: Log-encoded image

Converts linear-light pixel values to Cineon log encoding using the standard Cineon transfer curve. Apply at the end of a linear-space pipeline when the delivery requires a log-encoded DPX master.

No adjustable parameters.

Example — Log DPX delivery

After all compositing in linear space, insert Lin→Log immediately before the Output node when delivering a DPX log master to a colour grading suite.

 Log → Lin

Inputs: Image · Output: Linear-light image

Converts Cineon/DPX log-encoded pixel values to linear light using the standard Cineon transfer curve. Apply immediately after every Input node that reads Cineon/DPX footage so all downstream operations work in linear light.

No adjustable parameters.

Example — Standard log→linear pipeline setup

Place Log→Lin after every Input node reading DPX/log footage. Do all compositing and grading in linear space, then add Lin→Log before export if the delivery format requires log.

 LUT 1D

Inputs: Image, Matte (optional) · Output: LUT-graded image

Applies a 1D LUT from a .cube file. A 1D LUT maps each channel independently — ideal for tone-mapping curves, output transforms, and transfer-function conversions.

ParameterTypeRangeDefaultKeys
LUT File File path (.cube) — (none) —
Amount Float 0 – 1 1 —
Example — Camera log output transform

Load a camera manufacturer's 1D output LUT (e.g. S-Log3 → Rec.709 tone map). Set Amount to 1 for full application, or reduce to blend with the original for a partial look.

 LUT 3D

Inputs: Image, Matte (optional) · Output: LUT-graded image

Applies a 3D LUT from a .cube file using trilinear interpolation on a 3D color cube. Supports full creative and technical transforms including cross-channel color remapping impossible with a 1D LUT.

ParameterTypeRangeDefaultKeys
LUT File File path (.cube) — (none) —
Amount Float 0 – 1 1 —
Example — Film emulation look

Load a film emulation .cube (e.g. Kodak 2383 print emulation). Reduce Amount to 0.7 to retain natural color while adding the characteristic toe and shoulder of the film stock.

 Negative

Inputs: Image · Output: Color negative image

Creates an orange-masked color negative, replicating the appearance of an unexposed color film base. Inverts the image after applying an orange mask offset.

ParameterTypeRangeDefaultKeys
Amount Float 0 – 1 1 —
Orange Mask Float 0 – 1 0.35 —
Exposure Float −2 – +2 0 —
Example — Simulate a color film negative

Connect a scanned positive print to Negative at Amount 1.0, Orange Mask 0.35. Feed through a 3D LUT to color-correct back to a print-positive look.

 Posterize

Inputs: Image · Output: Posterized image

Reduces the number of tonal levels in each channel, creating a flat-colour posterized appearance. Per-Channel mode applies the reduction independently to R, G, and B for more colorful solarized results.

ParameterTypeRangeDefaultKeys
Levels Int 2 – 32 4 —
Per-Channel Bool on / off true —
Example — Pop-art style title card

Set Levels to 4, Per-Channel on. Feed into a Blend (Normal) at Mix 0.8 over the original for a posterized-over-photographic look.

 Saturation

Inputs: Image, Matte (optional) · Output: Saturation-adjusted image

Scales color saturation along the luminance axis. Values below 1 desaturate toward grey; values above 1 boost vivid colors. At 0 the output is a perceptual greyscale image.

ParameterTypeRangeDefaultKeys
Saturation Float 0 – 3 1 ✓
Example — Greyscale background to make the subject pop

Place a Saturation node at 0 on the background plate so the fully-saturated foreground subject stands out against a monochrome environment.

 Threshold

Inputs: Image, Matte (optional) · Output: Binary matte

Converts luminance to a soft binary mask. Pixels brighter than Value+Softness are white; pixels below Value−Softness are black; pixels in between are smoothly ramped. Useful for isolating highlights or creating matte sources.

ParameterTypeRangeDefaultKeys
Value Float 0 – 1 0.5 ✓
Softness Float 0 – 0.5 0.05 ✓
Example — Highlight mask for glow

Connect a Threshold (Value 0.85, Softness 0.05) to the Matte input of a Blur node at radius 12. Feed both through a Blend (Add) for a simple optical glow effect.

 Tint

Inputs: Image · Output: Tinted image

Applies a two-color tint mapped across the luminance range: a shadow color and a highlight color. Balance controls the luminance pivot. Amount blends between the tinted result and the original.

ParameterTypeRangeDefaultKeys
Shadow Color Color 0 – 1 each (0.1, 0.15, 0.3, 1) —
Highlight Color Color 0 – 1 each (1.0, 0.95, 0.85, 1) —
Balance Float 0 – 1 0.5 —
Amount Float 0 – 1 1 —
Example — Noir blue-shadow / warm-highlight look

Set Shadow Color to deep blue (0.05, 0.1, 0.25), Highlight Color to warm cream (1.0, 0.95, 0.82), Balance 0.45, Amount 0.6 for a bicolor grade that retains natural midtones.

 Vibrance

Inputs: Image · Output: Vibrance-adjusted image

Smartly boosts or reduces saturation with protection for already-vivid colors and skin tones. Has a stronger effect on muted colors and a gentler effect on saturated ones — unlike plain Saturation which treats all colors equally.

ParameterTypeRangeDefaultKeys
Amount Float −1 – +1 0.3 —
Example — Adding punch without over-saturating

After grading a flat plate, set Amount to 0.3–0.5. Already-saturated skies and foliage are protected while duller areas of the image gain color richness.

 White Balance

Inputs: Image · Output: White-balanced image

Corrects color temperature (warm/cool axis) and green-magenta tint to match a target white balance. Temperature shifts along the blue–orange axis; Tint shifts along the green–magenta axis.

ParameterTypeRangeDefaultKeys
Temperature Float −1 – +1 0 —
Tint Float −1 – +1 0 —
Example — Correcting tungsten-lit footage

For footage shot under tungsten with a daylight balance, set Temperature to +0.3 (warmer) and Tint to −0.05 to remove the slight green cast of the tungsten source.

Filter

 Anamorphic Blur

Inputs: Image · Output: Image with elongated oval bokeh

Asymmetric blur — separate X and Y radii — for the elongated oval bokeh characteristic of anamorphic cinema lenses. Highlight Boost (gamma applied before averaging) makes bright pixels bloom into vertical streaks instead of soft circles.

ParameterTypeRangeDefaultKeys
Radius X Int px 0 – 32 4 ✓
Radius Y Int px 0 – 32 12 ✓
Highlight Boost Float 1 – 8 2.0 ✓
Example — Cinematic vertical-streak bokeh

Set Radius X 3, Radius Y 14, Highlight Boost 4. Highlights stretch into the tall vertical streaks classic anamorphic lenses produce — the look that signals "shot on cinema glass." Pair with Z Defocus or Iris Blur for depth-driven anamorphic DOF.

 Blur

Inputs: Image, Matte (optional) · Output: Blurred image

Applies a separable two-pass Gaussian blur (horizontal then vertical). Performance is O(radius), making large radii practical on full-resolution plates.

ParameterTypeRangeDefaultKeys
Radius Float px 0 – 24 4 ✓
Example — Depth-of-field background blur

Isolate the background using a Roto or Luma Key matte, route it through Blur at radius 8–16, then composite the sharp foreground over it with a Blend (Normal) node.

 Chromatic Aberration

Inputs: Image · Output: Aberration-added image

Simulates lens chromatic aberration by radially offsetting the red and blue channels from the green, creating the colored fringing visible on low-quality lenses or at extreme focal lengths.

ParameterTypeRangeDefaultKeys
Amount Float 0 – 0.05 0.008 —
Example — Adding optical imperfection to CG

Apply at Amount 0.005–0.012 to a CG element to match the lens characteristics of the live-action plate it composites over. Makes optically-perfect CG renders feel physically real.

 Convolve 3×3

Inputs: Image · Output: Convolved image

Applies a 3×3 convolution kernel. Presets cover Box Blur, Gaussian, Sharpen, Edge, and Emboss. The Custom preset exposes all nine kernel weights and a bias for arbitrary linear filtering.

ParameterTypeRangeDefaultKeys
Preset Enum Identity · Box Blur · Gaussian · Sharpen · Edge · Emboss · Custom Identity —
Kernel [0,0]–[2,2] Float ×9 −8 – +8 Identity matrix —
Bias Float −1 – +1 0 —
Example — Custom Laplacian edge detector

Set Preset to Custom. Enter: corners −1, cross-edges −1, center 8. Set Bias to 0.5 to centre the result around grey for bidirectional edge visualization.

 Defocus

Inputs: Image · Output: Defocused image

Simulates lens defocus (bokeh) using a disc-shaped blur kernel. Highlight Boost brightens bright pixels before blurring, creating the bright specular bokeh discs characteristic of fast prime lenses.

ParameterTypeRangeDefaultKeys
Radius Int px 1 – 16 6 —
Highlight Boost Float 1 – 8 2 —
Example — Background bokeh from a fast lens

Set Radius 8, Highlight Boost 2.5. Bright specular highlights in the background become disc-shaped bokeh — unlike the soft rings a Gaussian Blur produces.

 Degrain

Inputs: Image · Output: Degrained image

Removes film grain using a bilateral spatial filter whose radius and range sigma are calibrated to a specific Kodak or Fuji motion-picture stock. The filter's kernel size and smoothing aggressiveness are derived from each stock's granularity and grain size, so selecting the correct stock avoids over-blurring fine-grained stocks (e.g. Fuji F-64D) or under-smoothing coarse ones (e.g. Tri-X Reversal).

ParameterTypeRangeDefaultKeys
Film Stock Enum 13 Kodak · 11 Fuji Vision3 500T (5219) —
Strength Float 0 – 2 1 ✓
Preserve Edges Float 0.01 – 0.2 0.05 —
Example — Grain exchange for seamless compositing

Select the stock that matches your scanned film — e.g. Fuji Eterna 250D (8563) for an Eterna-originated plate. Set Strength to 1.0 and Preserve Edges to 0.05. Composite clean CG elements over the degrained plate, then apply a Film Grain node set to the same stock on the final composite output. All layers share identical grain structure, eliminating the grain-mismatch artifact visible when only the background is grained.

 Descratch

Inputs: Image · Output: Scratch-healed image

Detects and heals vertical scratch lines common in film scans — the kind left by a grain of dirt caught in the projector gate. Detects bright vertical lines and replaces them with interpolated values from neighboring columns.

ParameterTypeRangeDefaultKeys
Threshold Float 0.01 – 0.6 0.12 —
Example — Removing a continuous film scratch

Run Descratch (Threshold 0.15) across a scratched sequence. For a scratch that varies in width, consider chaining two Descratch nodes at different thresholds or animating the Threshold parameter with keyframes.

 Dustbust

Inputs: Image · Output: Cleaned image

Automatically removes small dust spots and dirt particles from film scans. Compares each pixel against its 3×3 neighbourhood; extreme outliers beyond the Threshold are replaced with the local median.

ParameterTypeRangeDefaultKeys
Threshold Float 0 – 0.6 0.12 —
Example — Cleaning a 16mm film scan

Place Dustbust immediately after the Input node. Start at Threshold 0.12; increase toward 0.25 on heavily dusted frames. Lower values remove more spots but can slightly soften fine grain detail.

 Edge Blur

Inputs: Image · Output: Edge-blurred image

Applies blur selectively at detected edge locations while leaving flat areas unaffected. Useful for smoothing jagged or aliased matte edges without blurring the overall image.

ParameterTypeRangeDefaultKeys
Radius Int px 1 – 12 3 —
Edge Threshold Float 0 – 0.5 0.05 —
Example — Softening a hard key edge

After a Chroma Key, add Edge Blur at Radius 2, Edge Threshold 0.04. The node localises blur to the matte boundary, producing a natural soft edge without blurring internal subject detail.

 Edge Detect

Inputs: Image, Matte (optional) · Output: Edge map

Computes the Sobel gradient magnitude across all channels and returns a greyscale edge map. High values indicate strong edges; uniform regions return near-zero. Use as a matte source or for stylistic effects.

ParameterTypeRangeDefaultKeys
Strength Float 0 – 4 1 ✓
Example — Stylised edge overlay

Run Edge Detect at Strength 2, connect its output to a Blend (Add) node over the original plate for a graphic outlined look reminiscent of hand-drawn rotoscope animation.

 Emboss

Inputs: Image, Matte (optional) · Output: Embossed image

Applies a directional emboss filter that highlights surface relief as if lit from a specified angle. Used for stylised looks, bump-map generation, or displacement-texture sources.

ParameterTypeRangeDefaultKeys
Strength Float 0 – 4 1 ✓
Angle Float ° −180 – +180 45 ✓
Example — Pressed-metal title card

Route a white-text-on-black graphic through Emboss (Strength 2, Angle 135°), then blend it over a metal-texture plate using Blend (Overlay) for a raised-letter effect.

 Film Grain

Inputs: Image · Output: Grain-added image

Adds photochemically accurate film grain matched to 24 specific Kodak and Fuji motion-picture stocks. Each stock encodes its own spatial frequency, RMS granularity, and per-channel grain size. Fuji stocks exhibit finer, more uniform grain with a proportionally stronger green channel and cooler character compared to Kodak stocks at equivalent ISOs.

ParameterTypeRangeDefaultKeys
Film Stock Enum 13 Kodak · 11 Fuji Vision3 500T (5219) —
Amount Float 0 – 2 1 ✓
Monochrome Grain Bool on / off off —
Example — Matching plate grain for a digital intermediate

To match a Fuji Eterna 500T scan, select Fuji Eterna 500T (8573) at Amount 1.0. For a round-trip grain-exchange — degrain the plate, composite clean CG, then re-grain the result — use the same stock in both the Degrain and Film Grain nodes so grain structure is identical across all layers. Enable Monochrome Grain when graining over a B&W print output.

 Glow

Inputs: Image, Matte (optional) · Output: Glow-added image

Isolates pixels above a luminance threshold, blurs them, and additively composites the result back over the source. Simulates lens blooming on bright light sources or hot reflections.

ParameterTypeRangeDefaultKeys
Threshold Float 0 – 1 0.8 ✓
Radius Float px 0 – 32 8 ✓
Intensity Float 0 – 4 1 ✓
Example — Light-source halo

For shots with visible practical lights or LEDs, set Threshold 0.9, Radius 14, Intensity 1.5 for a subtle blooming halo that sells the brightness of the light source.

 Grain

Inputs: Image, Matte (optional) · Output: Grain-added image

Adds synthetic film grain using a per-frame seeded random-noise field. The seed changes every frame, simulating natural grain flutter rather than a static texture overlay.

ParameterTypeRangeDefaultKeys
Amount Float 0 – 0.4 0.05 ✓
Example — Matching grain to a film plate

Apply Grain at Amount 0.03–0.08 to a CG element before compositing it over a film plate. This prevents the CG element from looking artificially clean against the natural grain texture of the live-action footage.

 Highpass

Inputs: Image · Output: Highpass image

Subtracts a blurred version from the original, retaining only high-frequency detail. With Add to 50% Grey on, the output is centred at 0.5 grey — directly usable as an Overlay blend layer for frequency-separation retouching.

ParameterTypeRangeDefaultKeys
Radius Int px 1 – 24 6 —
Gain Float 0 – 8 1 —
Add to 50% Grey Bool on / off true —
Example — Frequency separation sharpening

Feed the same source into Blur (low-frequency) and Highpass (high-frequency) at matching Radius. Blend the Highpass output over the Blur using Blend (Overlay) to reassemble with sharpened detail on smooth colour.

 Iris Blur

Inputs: Image · Output: Image with circular focus region

Radial focus region without a depth pass. A circular sharp area at Center X/Y stays in focus inside Focus Radius; the blur ramps up to Max Radius at Falloff Radius and beyond. Aspect-corrected so the focus region stays circular regardless of frame shape. Used heavily in motion graphics, product shots, and stylized portraits.

ParameterTypeRangeDefaultKeys
Center X Float 0 – 1 0.5 ✓
Center Y Float 0 – 1 0.5 ✓
Focus Radius Float 0 – 1 0.15 ✓
Falloff Radius Float 0 – 2 0.5 ✓
Max Radius Int px 1 – 24 10 —
Example — Spotlight a face on a busy background

Place Center X/Y over the subject, Focus Radius 0.12, Falloff Radius 0.45, Max Radius 16. The face stays sharp; the background blurs progressively to a strong defocus. Animate Center X/Y to follow a moving subject.

 Lens Flare

Inputs: Image · Output: Flare-composited image

Synthesises a multi-element lens flare: central hotspot, diffusion halo, anamorphic streaks, secondary ghost reflections, and chromatic fringing — all additively composited over the input image.

ParameterTypeRangeDefaultKeys
Position X Float 0 – 1 0.7 —
Position Y Float 0 – 1 0.3 —
Intensity Float 0 – 4 1 —
Hotspot Size Float 0 – 0.5 0.05 —
Halo Size Float 0 – 1 0.25 —
Streak Length Float 0 – 2 0.7 —
Streak Width Float 0.001 – 0.2 0.02 —
Ghosts Float 0 – 2 0.6 —
Chromatic Shift Float 0 – 0.05 0.012 —
Example — Sun flare through a window

Place Position X/Y at the window location. Keyframe Intensity to peak as the camera reveals the sun — simulating natural flare flutter as the camera angle changes.

 Median

Inputs: Image, Matte (optional) · Output: Median-filtered image

Applies a median filter over a 3×3 or 5×5 neighbourhood. Excellent at removing salt-and-pepper noise and isolated pixel defects while preserving hard edges better than a Gaussian blur.

ParameterTypeRangeDefaultKeys
Radius Int 1 (3×3) – 2 (5×5) 1 —
Example — Cleaning sensor hot pixels

Place a Median node (Radius 1) early in the graph — after the Input — to suppress isolated hot pixels common in long-exposure or high-ISO footage before any keying or grading operation.

 Motion Blur

Inputs: Image, Matte (optional) · Output: Motion-blurred image

Applies a linear directional blur along a specified angle and length. Use to add synthetic motion blur to a CG element, to simulate camera pan blur, or to sell the speed of a tracked insert.

ParameterTypeRangeDefaultKeys
Angle Float ° 0 – 360 0 ✓
Length Float px 0 – 64 12 ✓
Example — Per-frame velocity-matched motion blur

From the tracker data, compute each frame's dx/dy delta and convert to polar angle and magnitude. Keyframe both Motion Blur Angle and Length to match — the element blurs naturally as it moves fast and sharpens when it slows.

 Sharpen

Inputs: Image, Matte (optional) · Output: Sharpened image

Applies an unsharp mask: a blurred version is subtracted from the original and the difference (high-frequency detail) is added back at the specified Amount. Enhances perceived crispness without changing overall luminance.

ParameterTypeRangeDefaultKeys
Amount Float 0 – 4 0.5 ✓
Example — Recovering sharpness from a soft scan

After Log→Lin on a film scan, add Sharpen at Amount 0.3–0.6 to recover grain-level sharpness lost during scanning. Avoid values above 1.5 which introduce ringing on hard edges.

 Tilt-Shift

Inputs: Image · Output: Image with gradient-driven blur

Linear-gradient depth-of-field. A sharp band of width Band Height runs across the frame at Focus Y, perpendicular to the Angle direction; pixels outside the band blur progressively to Max Radius. No depth pass needed — the focus axis is screen-space. Mimics a tilt-shift lens; the famous "miniature world" look comes from a horizontal sharp band on a top-down composition.

ParameterTypeRangeDefaultKeys
Focus Y Float 0 – 1 0.5 ✓
Band Height Float 0 – 1 0.15 ✓
Max Radius Int px 1 – 24 10 —
Angle Float° -180 – 180 0 ✓
Example — Miniature-effect cityscape

Set Angle to 0 (horizontal band), Focus Y to 0.55 (slightly below center, where the subject sits), Band Height 0.12, Max Radius 14. The band stays sharp; the sky and foreground blur progressively. The shallow depth-of-field reads as if the scene were a tabletop model.

 Vignette

Inputs: Image · Output: Vignette-added image

Adds a radial brightness falloff from the frame center. Negative Amount darkens edges (classic vignette); positive Amount brightens them (anti-vignette). Radius and Softness control the ellipse shape and feather.

ParameterTypeRangeDefaultKeys
Amount Float −1 – +1 0.5 —
Radius Float 0.1 – 2 0.9 —
Softness Float 0.01 – 1 0.5 —
Example — Subtle cinematic edge darkening

Set Amount −0.35, Radius 0.85, Softness 0.6 for a gentle vignette that draws the eye center without being obvious. Apply as the last node before Output.

 Z Blur

Inputs: Image, Depth map · Output: Depth-blurred image

Applies depth-of-field blur driven by a greyscale depth map. Pixels near the Focus Depth remain sharp; pixels further away are blurred proportionally up to Max Radius. Produces per-pixel defocus without 3D renders.

ParameterTypeRangeDefaultKeys
Focus Depth Float 0 – 1 0.5 —
Focus Range Float 0.01 – 1 0.25 —
Max Radius Int px 1 – 24 8 —
Invert Depth Bool on / off false —
Example — DOF from a rendered Z-pass

Connect the beauty render to BG and the normalised Z-pass to Depth. Set Focus Depth to the normalised depth of your subject, Focus Range 0.15, Max Radius 10. Enable Invert Depth if your Z-pass encodes near=1/far=0.

 Z Defocus

Inputs: Image, Depth map · Output: Defocused image with shaped bokeh

Cinematic depth-of-field — combines Z Blur's per-pixel depth-driven radius with a shaped iris (disc, hexagon, or square) and Highlight Boost so bright pixels bloom into iris-shaped bokeh. Use for finishing-quality DOF; use Z Blur when you just need a fast soft falloff.

ParameterTypeRangeDefaultKeys
Focus Depth Float 0 – 1 0.5 —
Focus Range Float 0.01 – 1 0.25 —
Max Radius Int px 1 – 24 10 —
Iris Shape Enum Disc · Hexagon · Square Disc —
Highlight Boost Float 1 – 8 2.0 —
Invert Depth Bool on / off false —
Example — Hexagonal-iris bokeh on a portrait plate

Connect the plate to BG and the depth pass to Depth. Set Iris Shape to Hexagon, Focus Depth at the subject's depth value, Focus Range 0.12, Max Radius 14, Highlight Boost 4. Bright background highlights bloom into hexagonal bokeh shapes characteristic of fast cine primes; the subject stays sharp inside the focal range.

Channel

 Channel Copy

Inputs: Destination (BG), Source (FG) · Output: Channel-modified image

Copies a specified channel from the FG image into a specified channel of the BG image. All other BG channels pass through unchanged. Essential for injecting a custom alpha or replacing a single color channel.

ParameterTypeRangeDefaultKeys
Destination (BG channel) Enum Red · Green · Blue · Alpha Alpha —
Source (FG channel) Enum Red · Green · Blue · Alpha · Luma Luma —
Example — Injecting a custom alpha channel

Connect a beauty render to BG and a separately rendered alpha/matte to FG. Set Source to Luma, Destination to Alpha. The RGB remains untouched and now carries the correct alpha for compositing.

 Channel Merge

Inputs: R input, G input, B input, A input · Output: Merged RGBA image

Builds a new RGBA image by selecting one channel from each of up to four independent input images. Each output channel independently selects its source from R, G, B, A, Luma, or constant One.

ParameterTypeRangeDefaultKeys
R From Enum Red · Green · Blue · Alpha · Luma Red —
G From Enum Red · Green · Blue · Alpha · Luma Green —
B From Enum Red · Green · Blue · Alpha · Luma Blue —
A From Enum Red · Green · Blue · Alpha · Luma · One One —
Example — Assembling multi-pass CG renders

Connect a beauty render to R input, a specular pass to G input, a diffuse pass to B input. Set R/G/B From to Red/Green/Blue, A From to One. Each render pass becomes a separate color channel you can grade independently downstream.

 Channel Remove

Inputs: Image · Output: Channel-zeroed image

Zeroes out any combination of R, G, B, and A channels while leaving others unchanged. Use to isolate a single channel, clear an unwanted alpha, or zero a color channel for diagnostic work.

ParameterTypeRangeDefaultKeys
Red Bool on / off false —
Green Bool on / off false —
Blue Bool on / off false —
Alpha Bool on / off false —
Example — Clearing an unwanted embedded alpha

Enable the Alpha toggle to zero the alpha channel of an image with an unwanted embedded matte. The RGB passes through unchanged; the image is now treated as fully opaque downstream.

 Premult

Inputs: Image · Output: Premultiplied image

Multiplies each RGB channel by the alpha channel (R×A, G×A, B×A). Converts a straight-alpha image to premultiplied format required by most compositing blend operations.

No adjustable parameters.

Example — Preparing a straight-alpha CG render

CG renderers often output straight alpha. Insert Premult before connecting a CG element to a Blend node to avoid "white fringe" artifacts at transparent edges.

 Shuffle

Inputs: Image · Output: Channel-shuffled image

Reroutes RGBA channels to different output slots. Extract a single channel as a greyscale image, swap Red and Blue for a format conversion, or isolate the alpha channel for matte operations.

ParameterTypeRangeDefaultKeys
Mode Enum RGBA · BGRA · R→RGB · G→RGB · B→RGB · A→RGB · BGR RGBA —
Example — Extracting the alpha as a luminance matte

Set Mode to A→RGB to copy the alpha channel into all three RGB channels (alpha set to 1). Feed the result into a Luma Key to create a luminance matte from an existing alpha pass.

 Unpremult

Inputs: Image · Output: Straight-alpha image

Divides each RGB channel by the alpha channel (R÷A, G÷A, B÷A). Converts premultiplied to straight alpha. Always apply before color-correcting a premultiplied element to avoid edge darkening.

No adjustable parameters.

Example — Color-correcting a premultiplied element

Chain: Input → Unpremult → Color Balance → Premult. The sandwich ensures color corrections are applied to true pixel values, not values already modulated by alpha.

Keyer

 Chroma Key

Inputs: Image, Matte (optional) · Output: Keyed RGBA image

Removes a specific screen color (green, blue, etc.) using either a fast Euclidean RGB Distance or the broadcast-standard Color Difference algorithm. Includes despill to remove residual screen color reflected onto the subject.

ParameterTypeRangeDefaultKeys
Method Enum RGB Distance · Color Difference Color Difference —
Key Color R/G/B Float×3 0 – 1 each 0, 1, 0 (green) —
Tolerance Float 0 – 1 0.3 ✓
Falloff Float 0 – 0.5 0.15 ✓
Despill Float 0 – 1 1 —
Shrink Float 0 – 0.5 0.05 ✓
Example — Standard greenscreen key

Connect the greenscreen plate to input[0]. Sample the background green with the color picker. Set Method to Color Difference, Tolerance 0.35, Falloff 0.1, Despill 1.0. Increase Shrink slightly to tighten a fringe edge on fine hair.

 Difference Key

Inputs: Plate (BG), Clean plate (Clean) · Output: Difference matte

Generates a matte by computing the absolute per-pixel difference between a plate and a clean reference. Pixels that have changed beyond the Tolerance threshold become white. Simple and effective for locked-off camera shots.

ParameterTypeRangeDefaultKeys
Tolerance Float 0 – 1 0.05 —
Softness Float 0.01 – 1 0.1 —
Example — Removing a rig from a locked-off shot

Shoot a clean plate without the rig. The matte reveals only the rig pixels. Feed into a Keymix to replace the rig area with the clean background plate.

 Hue Key

Inputs: Image · Output: Hue-keyed matte

Keys based on hue angle rather than absolute color, making it more robust to lighting variation. A hue range and softness define the acceptance zone on the color wheel. Minimum Saturation prevents greys and near-whites from being pulled.

ParameterTypeRangeDefaultKeys
Hue (°) Float 0 – 360 120 —
Range (°) Float 0 – 180 30 —
Softness (°) Float 0 – 90 10 —
Min Saturation Float 0 – 1 0.15 —
Example — Keying a non-standard screen color

For a pink or orange screen, set Hue to the screen's hue angle, Range 25°, Softness 8°. Min Saturation 0.2 prevents low-saturation flesh tones from being pulled into the key.

 IBK (Image-Based Keyer)

Inputs: Plate (BG), Clean plate (Clean), Matte (optional) · Output: Keyed RGBA image

Compares the plate against a clean-plate reference to generate a highly accurate matte even under uneven screen lighting. Requires a clean plate from the same shot setup. Includes despill.

ParameterTypeRangeDefaultKeys
Screen Enum Green · Blue · Red Green —
Tolerance Float 0 – 1 0.1 —
Softness Float 0.001 – 1 0.1 —
Despill Float 0 – 1 0.6 —
Output Enum Premultiplied · Matte Only Premultiplied —
Example — Uneven greenscreen with a clean plate

Shoot an empty frame of the greenscreen before the take. Connect the subject plate to BG and the clean plate to Clean. IBK's per-pixel subtraction handles lighting gradients that defeat a standard chroma keyer.

 Luma Key

Inputs: Image, Matte (optional) · Output: Keyed RGBA image

Keys (removes) pixels based on luminance. Pixels between the Low and High thresholds become transparent; pixels outside remain opaque. Soft falloffs at each boundary prevent hard matte edges.

ParameterTypeRangeDefaultKeys
Low Float 0 – 1 0.1 ✓
High Float 0 – 1 0.9 ✓
Invert Bool on / off off —
Example — Pulling a white-screen key

For footage shot on a white backing, set Low to 0.75, High to 1.0, and enable Invert. This keys out the bright white backing while retaining the darker subject.

 Matte Blur

Inputs: Matte · Output: Blurred matte

Blurs the edges of a matte using a Gaussian blur, producing a natural soft falloff at matte boundaries. Use after morphological operations to smooth any staircasing or harshness introduced by erode/dilate.

ParameterTypeRangeDefaultKeys
Radius Int px 1 – 16 4 —
Example — Softening the final matte edge

Chain as the last step in a matte operation sequence (Erode → Dilate → Matte Blur). Radius 2–4 adds a natural soft falloff, particularly important on fine hair that would otherwise show a hard composite boundary.

 Matte Dilate

Inputs: Matte · Output: Dilated matte

Expands the white area of a matte outward using a morphological maximum (dilation). Recovers fine detail that an over-aggressive key or erosion may have removed.

ParameterTypeRangeDefaultKeys
Radius Int px 1 – 8 2 —
Example — Recovering eroded hair detail

After Matte Erode, apply Matte Dilate at Radius 1. The Erode→Dilate pair (morphological open) removes fringe without permanently losing fine edge structure like hair or flyaways.

 Matte Erode

Inputs: Matte · Output: Eroded matte

Shrinks the white area of a matte inward using a morphological minimum (erosion). Removes thin fringe pixels from over-expanded key mattes while preserving the overall shape.

ParameterTypeRangeDefaultKeys
Radius Int px 1 – 8 2 —
Example — Tightening a loose key edge

After Chroma Key, if the matte has a thin bright fringe, apply Matte Erode at Radius 1–2. This trims the overgrown boundary without affecting the solid interior of the matte.

 Matte Math

Inputs: Matte A, Matte B · Output: Combined matte

Performs a mathematical operation between two mattes. Use to combine results from multiple keyers, subtract a garbage matte from a key, or intersect a roto shape with a chroma key result.

ParameterTypeRangeDefaultKeys
Operation Enum Union (max) · Intersect (min) · Subtract (A−B) · Difference (|A−B|) · Add Union (max) —
Example — Confine a chroma key with a roto shape

Feed the Chroma Key matte to A and a Roto garbage matte to B. Set Operation to Intersect (min) to restrict the key result to the performer's area, eliminating spill from set walls outside the roto boundary.

 Roto

Output: Animated bezier matte

Generates an animated bezier spline matte. Knots are placed interactively on the canvas; tangent handles control curvature. Each keyframe stores the full spline shape and Lightform FX interpolates smoothly between keyframes.

ParameterTypeRangeDefaultKeys
Feather Float 0 – 0.1 0 —
Opacity Float 0 – 1 1 —
Invert Bool on / off off —
Example — Isolating a moving subject

Select the Roto node and click the canvas to place knots around the subject's outline. Drag tangent handles to curve edges. Advance 10–15 frames, reposition knots to the new pose, and press ◆ Set Key. Repeat at key poses throughout the shot. Connect the Roto output to a Blend node's Matte input.

 Spill Suppress

Inputs: Image · Output: Despilled image

Targeted suppression of screen-color spill (reflected green or blue) from a keyed subject. Use after keying when the Chroma Key node's built-in despill is insufficient for heavily spill-lit subjects.

ParameterTypeRangeDefaultKeys
Spill Channel Enum Green · Blue · Red Green —
Amount Float 0 – 1 1 —
Example — Removing stubborn green from hair

Chain after Chroma Key. Set Spill Channel to Green, Amount 0.7. The targeted suppression removes residual green without desaturating the subject's natural hair color the way full despill can.

 Wire Removal

Inputs: Image · Output: Wire-removed image

Removes wire rigs, fishing lines, or visible support cables by detecting pixels that match the screen color and replacing them with spatially interpolated values from surrounding pixels. Works best on relatively uniform backgrounds.

ParameterTypeRangeDefaultKeys
Screen Color R/G/B Float×3 0 – 1 each 0, 1, 0 —
Tolerance Float 0 – 1 0.25 —
Softness Float 0 – 0.5 0.08 —
Search Radius Int px 1 – 128 32 —
Example — Removing a safety wire against sky

Set Screen Color to match the sky or background behind the wire, Tolerance 0.2, Search Radius 24. The node searches horizontally within the radius for a clean background pixel to copy over the wire's location.

Transform

 Camera Shake

Inputs: Image · Output: Shake-added image

Adds procedural synthetic camera shake using Perlin-noise-driven translation. Frequency controls the speed of movement; Amplitude the pixel range of travel; Seed changes the motion path.

ParameterTypeRangeDefaultKeys
Amplitude (px) Float 0 – 100 12 —
Frequency Float 0.1 – 20 6 —
Seed Float 0 – 100 1 —
Example — Simulating handheld footage

Set Amplitude 8, Frequency 5. Increase to Amplitude 20–40 and Frequency 12 for action-cam or earthquake simulation. Change Seed to get a different motion path.

 Crop

Inputs: Image · Output: Cropped image

Crops the image by normalised insets on each side. Values run 0 (no crop) to 1 (fully cropped). Output resolution is unchanged — cropped regions become transparent black.

ParameterTypeRangeDefaultKeys
Left Float 0 – 1 0 —
Right Float 0 – 1 0 —
Top Float 0 – 1 0 —
Bottom Float 0 – 1 0 —
Example — Letterboxing for 2.39:1

To letterbox a 1.78 frame to 2.39, set Top and Bottom each to 0.132. This removes ~13.2% from each edge, producing the 2.39:1 widescreen aspect ratio.

 Displace

Inputs: Image (BG), Displacement map (FG) · Output: Displaced image

Offsets BG pixels using a displacement map. By default luminance drives uniform X+Y displacement. Enable Use R/G Channels to drive horizontal and vertical displacement independently from the Red and Green channels.

ParameterTypeRangeDefaultKeys
Amount (px) Float 0 – 200 20 —
Use R/G Channels Bool on / off false —
Example — Heat shimmer / mirage effect

Drive Displace with a slowly animated Fractal Noise node at Amount 8–15 px. The subtle per-pixel displacement creates convincing heat-shimmer distortion over a background plate.

 Flip

Inputs: Image · Output: Flipped image

Mirrors the image horizontally (X axis), vertically (Y axis), or both. Useful for matching mirror-image plates, correcting reversed film scans, or achieving stylistic symmetry.

ParameterTypeRangeDefaultKeys
Mode Enum None · X · Y · Both X —
Example — Correcting a reversed negative scan

If a scanned film negative was digitised emulsion-side up, set Flip Mode to X to mirror the left-right reversal and restore the correct orientation.

 Lens Distort

Inputs: Image · Output: Lens-distorted image

Applies radial lens distortion via the Brown–Conrady model (K1 and K2 coefficients). Positive values produce barrel distortion; negative values produce pincushion. Use to match or remove the distortion of a real lens.

ParameterTypeRangeDefaultKeys
K1 (radial) Float −1 – +1 0 —
K2 (higher order) Float −1 – +1 0 —
Example — Undistorting for 3D tracking

Negate the K1/K2 values from a lens calibration solve to undistort the plate before a 3D tracking pass, then apply the original K1/K2 to re-distort CG renders in post.

 Mirror

Inputs: Image · Output: Mirrored image

Creates a mirror reflection by copying one half of the image over the other across a pivot line. Mode selects which half is the source; Pivot shifts the axis position.

ParameterTypeRangeDefaultKeys
Mode Enum Left→Right · Right→Left · Top→Bottom · Bottom→Top Left→Right —
Pivot Float 0 – 1 0.5 —
Example — Symmetrical set extension

Set Mode to Left→Right, Pivot 0.5 to create a perfectly symmetrical frame from the left half — a common technique for extending a practical background set on one axis.

 Perspective

Inputs: Image, Matte (optional) · Output: Perspective-warped image

Applies a 3D perspective distortion by rotating the image plane around its X, Y, and Z axes with a configurable virtual camera distance. Simulates camera angle changes or creates 3D title animations.

ParameterTypeRangeDefaultKeys
Rotation X Float ° unbounded 0 —
Rotation Y Float ° unbounded 0 —
Rotation Z Float ° unbounded 0 —
Distance Float > 0 2 —
Example — 3D card flip animation

Place a graphic over a Constant background, feed through Perspective, and keyframe Rotation Y from 0° to 360° over 60 frames for a full card flip. Increase Distance to reduce foreshortening at extreme angles.

 Polar

Inputs: Image · Output: Polar-transformed image

Converts between rectangular (Cartesian) and polar coordinate spaces. Rect→Polar wraps the image into a circular form; Polar→Rect unwraps it.

ParameterTypeRangeDefaultKeys
Mode Enum Rect → Polar · Polar → Rect Rect → Polar —
Example — Circular tunnel effect

Feed a horizontal gradient or strip of text through Polar (Rect → Polar). The horizontal content wraps into a ring, creating a planet-ring or tunnel warp effect common in motion graphics.

 Reformat

Inputs: Image · Output: Reformatted image

Resizes the output to a specified width and height. Stretch fills the frame; Letterbox preserves aspect ratio with transparent bars; Crop fills the frame by cropping edges.

ParameterTypeRangeDefaultKeys
Output Width Int px 16 – 8192 1920 —
Output Height Int px 16 – 8192 1080 —
Fit Enum Stretch · Letterbox · Crop Letterbox —
Example — Downscale to 720p web proxy

Set Width 1280, Height 720, Fit Letterbox. Place Reformat before Output for web delivery while keeping the master graph at full 1080p.

 STMap

Inputs: Image (BG), UV map (FG) · Output: UV-warped image

Warps BG using a UV (ST) map where the Red channel encodes X position and Green encodes Y position (both 0–1 normalised). Enables arbitrary per-pixel distortion from pre-computed warp maps generated in 3D software.

ParameterTypeRangeDefaultKeys
Flip V Bool on / off false —
Example — 3D match-move with a baked warp map

Export a UV warp map from your 3D application. Connect the beauty render to BG and the UV map to FG. Enable Flip V if your UV origin is top-left (OpenGL/Metal convention).

 Tile

Inputs: Image · Output: Tiled image

Tiles the input in an M×N grid. Mirror Every Other reflects alternating tiles so adjacent tiles share edges without a visible seam, enabling seamlessly tiling textures.

ParameterTypeRangeDefaultKeys
Tiles X Int 1 – 32 3 —
Tiles Y Int 1 – 32 3 —
Mirror Every Other Bool on / off false —
Example — Seamless texture background

Connect a 480×270 texture to Tile with Tiles X and Y both 4 and Mirror Every Other on. The result fills 1920×1080 with a seamlessly mirrored repeat and no visible boundary.

 Transform

Inputs: Image, Matte (optional) · Output: Transformed image

Applies a 2D affine transform: translation, uniform scale, and rotation around the image center. Transform order: scale → rotate → translate.

ParameterTypeRangeDefaultKeys
Translate X Float px −500 – +500 0 ✓
Translate Y Float px −500 – +500 0 ✓
Scale Float 0.05 – 4 1 ✓
Rotation Float ° −180 – +180 0 ✓
Example — Animated title slide-in

At frame 1, keyframe Translate X at −200. At frame 20, keyframe at 0. The title slides in from the left over 20 frames. Add a Scale animation from 0.8 to 1.0 for a push-in effect.

Tracking

 Match Move

Inputs: Reference plate (BG), Foreground element (FG) · Output: Position-matched image

Tracks a single feature point across the timeline using NCC template matching and applies the resulting translation to the FG input. Positive Strength follows the track; negative Strength applies the inverse (stabilisation). Both inputs can be the same plate for a pure stabilise effect.

ParameterTypeRangeDefaultKeys
Reference Frame Int 1 – last frame 1 —
Track X / Y Float norm. 0 – 1 0.5, 0.5 —
Patch Size Int px 8 – 128 32 —
Search Radius Int px 4 – 128 24 —
Strength Float −2 – +2 1 —
Example — Locking a lower-third to a moving surface

Connect the reference plate to BG and your graphic to FG. Pick a stationary feature on the surface. Click Compute Track. At Strength 1 the graphic sticks to the surface; at −1 it counteracts the motion for stabilisation.

 Planar Track

Inputs: Reference plate (BG), Foreground element (FG) · Output: Corner-pin warped image

Tracks a planar surface defined by four corner points using an inverse-compositional Lucas-Kanade (IC-LK) homography optimizer (Baker & Matthews 2004). Solves the full 8-DOF projective transform across the entire patch — the gold standard for flat-surface replacement (screens, signs, billboards).

ParameterTypeRangeDefaultKeys
Reference Frame Int 1 – last frame 1 —
Corner 0–3 X / Y Float norm. 0 – 1 (centred quad) —
Patch Size Int px 8 – 128 32 —
Search Radius Int px 4 – 128 24 —
Example — Screen replacement on a billboard

Set the reference frame to a frame where the billboard is fully visible. Drag each corner handle to the four corners of the billboard face. Click Compute Track — the tracker sweeps forward and backward from the reference using IC-LK. Connect your replacement artwork to FG; it will be homography-warped to the billboard's perspective throughout the shot.

 Point Tracker

Inputs: Plate · Output: Plate (pass-through)

Multi-point 2D tracker that doubles as a camera-tracker foundation. Place up to 16 feature points on a reference frame; the host NCC-matches each across the timeline (subpixel-refined), then can solve a relative camera pose between any two frames, chain consecutive solves into a per-frame world-space trajectory, triangulate the 2D points into a 3D point cloud, and globally refine everything via dense bundle adjustment. The output texture passes through unchanged — the value is in the solved data, which Camera 3D and Card 3D nodes read by linking to this tracker.

ParameterTypeRangeDefaultKeys
Ref Frame Int 1 – last 1 —
Patch Size Int px 8 – 128 32 —
Search Radius Int px 4 – 128 24 —
Per-point X / Y Float norm. 0 – 1 (varies) —
Frame A / Frame B (pose solve) Int 1 – last 1, 2 —
Example — Camera-locked card on a panning shot

Connect the plate to the Plate input. Click Add Point 8 to 12 times and drag each point onto a stable feature in the scene (corners of objects, high-contrast textures — avoid foliage and people). Set Patch Size 32, Search Radius 24, then Compute Track to walk the timeline.

Once tracking lands: Solve Trajectory chains pairwise pose solves into a per-frame world-space camera trajectory and triangulates the cloud of 3D points. Refine (Bundle Adjust) minimizes total reprojection error globally — caption shows how many ×-improvement BA produced.

To use the result: drop a Camera 3D node and set its Track Source to this Point Tracker; drop a Card 3D, set its Snap Source to this tracker and pick a Snap Point #; wire your image into the Card's Tex socket and a Render 3D node consumes both. The card now sits locked to the tracked feature in 3D space as the camera animates.

Tip on lens accuracy: wire the Camera 3D's Track Source link before running Solve Trajectory, and set the Camera's Focal (mm) and Sensor (mm) to match the lens that shot the plate. The tracker reads those values when building the projection matrix; the placeholder 50 mm / 24 mm fallback only applies when no Camera is linked.

 Stabilize

Inputs: Image to stabilize · Output: Stabilized image

Reads tracking data from an upstream Match Move, Two-Point Track, or Planar Track node and applies the inverse transform to lock the tracked feature to its reference-frame position. Removes camera shake and handheld motion.

ParameterTypeRangeDefaultKeys
Source Tracker Node reference Any tracker node (none) —
Strength Float 0 – 1 1 —
Example — Smoothing a handheld interview shot

Track a fixed background detail (door frame, wall corner) with a Match Move node. Create a Stabilize node, link Source Tracker to that Match Move, then feed the plate through Stabilize. Strength 1 fully locks the background; 0.7–0.9 leaves a subtle natural-movement feel.

 Two-Point Track

Inputs: Reference plate (BG), Foreground element (FG) · Output: Similarity-transformed image

Tracks two independent feature points and derives a similarity transform (translation + rotation + uniform scale) from their relative motion. Ideal for rigid objects that simultaneously move, rotate, and scale in frame.

ParameterTypeRangeDefaultKeys
Reference Frame Int 1 – last frame 1 —
Point 0 X / Y Float norm. 0 – 1 0.35, 0.5 —
Point 1 X / Y Float norm. 0 – 1 0.65, 0.5 —
Patch Size Int px 8 – 128 32 —
Search Radius Int px 4 – 128 24 —
Strength Float −2 – +2 1 —
Example — Laptop screen replacement

Place the two tracker points on diagonally opposite corners of the laptop screen bezel. Run Compute Track. The FG element (your replacement graphic) will be translated, rotated, and scaled to perfectly match the laptop movement throughout the shot.

Composite

 Blend

Inputs: Background (BG), Foreground (FG), Matte (optional) · Output: Composited image

Composites the FG layer over the BG layer using one of eight blend modes. The optional Matte input restricts blending to the matte's white areas. Mix controls overall FG opacity and is keyframeable for dissolves.

ParameterTypeRangeDefaultKeys
Mode Enum Normal · Add · Multiply · Screen · Overlay · Difference · Min · Max Normal —
Mix Float 0 – 1 1 ✓
Example — Standard over composite

Connect the background plate to BG, the keyed foreground to FG, and the key matte to Matte. Set Mode to Normal, Mix 1.0. The FG alpha combined with the matte determines how much of each FG pixel shows over the background.

 Dissolve

Inputs: A, B · Output: Cross-faded image

Linearly cross-fades between inputs A and B. At Mix 0 the output is entirely A; at Mix 1 it is entirely B. Keyframe Mix for a traditional cross-dissolve transition.

ParameterTypeRangeDefaultKeys
Mix Float 0 – 1 0.5 —
Example — Scene cross-dissolve

Connect outgoing shot to A, incoming to B. Keyframe Mix from 0 to 1 over 24 frames for a one-second dissolve between scenes.

 Edge Extend

Inputs: Image · Output: Edge-extended image

Extends the outermost opaque edge pixels outward into the transparent region. Eliminates the dark fringe that appears when a premultiplied element is transformed or scaled, because there are no longer transparent-black pixels at the boundary.

ParameterTypeRangeDefaultKeys
Radius (px) Int px 1 – 32 6 —
Example — Eliminating dark fringe on a Transform

Apply Edge Extend (Radius 4–8) before any Transform node on a keyed element. The extended edge pixels fill the transparent border, preventing the fringe artifact when the transformed image is composited over a colored background.

 Keymix

Inputs: Background (BG), Foreground (FG), Matte · Output: Keymixed image

Composites FG over BG using a specified channel of the Matte input. More flexible than a standard Blend because you can select which channel (Alpha, R, G, B, or Luma) drives the mix.

ParameterTypeRangeDefaultKeys
Matte Channel Enum Alpha · Red · Green · Blue · Luma Alpha —
Invert Matte Bool on / off false —
Example — Composite using a green-channel matte

If a keyer outputs its holdout in the green channel rather than alpha, set Matte Channel to Green in Keymix — no Shuffle node required.

 Light Wrap

Inputs: Background (BG), Foreground (FG), Matte (optional) · Output: Light-wrapped composite

Blurs the background colors and wraps them around the edges of the foreground element, creating the appearance that background light spills onto the foreground. Essential for integrating keyed elements into colorful or bright backgrounds.

ParameterTypeRangeDefaultKeys
Radius (px) Int px 1 – 32 8 —
Intensity Float 0 – 4 1 —
Use FG Alpha as Matte Bool on / off true —
Example — Integrating a keyed actor into a sunset

Set Radius 12, Intensity 0.8. The warm orange sunset colors bleed onto the actor's hair and shoulders, selling the integration far better than a clean composite alone.

 Switch

Inputs: A, B · Output: Selected image

Passes either input A or input B to the output. Use to toggle between two versions of a composition, switch proxy vs. full-quality, or build A/B comparison setups without rewiring.

ParameterTypeRangeDefaultKeys
Output Enum A · B A —
Example — A/B grade comparison

Connect two different grade chains to A and B. Toggle Output between A and B in the Parameters panel to instantly compare the two approaches.

Time

 Deflicker

Inputs: Image · Output: Deflickered image

Reduces inter-frame brightness flicker common in time-lapse footage, scanned film, or variable-shutter recordings. Normalises each frame's average luminance (or per-channel values) toward the running average over a temporal window.

ParameterTypeRangeDefaultKeys
Window Radius Int 1 – 10 3 —
Correction Enum Luminance · Per-Channel Luminance —
Strength Float 0 – 1 1 —
Example — Time-lapse flicker removal

Set Window Radius 5, Correction Luminance, Strength 0.9. Leave Strength below 1 to avoid over-smoothing intentional exposure transitions. Use Per-Channel for mixed-lighting colour flicker.

 Frame Blend

Inputs: Image · Output: Blended image

Blends adjacent frames into each output frame. Radius controls how many frames on each side contribute. Box gives equal weight; Gaussian gives more weight to the central frame. Used for motion blur simulation or frame-rate conversion smoothing.

ParameterTypeRangeDefaultKeys
Radius (frames) Int 0 – 8 1 —
Weight Shape Enum Box · Gaussian Box —
Example — Simulating 180° shutter motion blur

Set Radius 1, Weight Shape Box to blend 3 consecutive frames (−1, 0, +1) equally — equivalent to a 180° shutter on 24fps footage. Radius 2 with Gaussian gives a more natural shutter-blur falloff.

 Retime

Inputs: Image · Output: Retimed image

Changes the playback speed of a clip. Speed 2.0 doubles the rate; Speed 0.5 halves it. Anchor Frame sets which source frame aligns with output frame 0. Blend interpolation averages adjacent frames for smoother slow motion.

ParameterTypeRangeDefaultKeys
Speed Float −4 – +4 1 —
Anchor Frame Int unbounded 0 —
Interpolation Enum Nearest · Blend Blend —
Example — Half-speed slow motion

Set Speed 0.5, Interpolation Blend. Adjacent source frames are blended at each half-frame position, producing smoother motion than Nearest which would stutter on every other frame.

Paint / Roto

 Garbage Matte

Inputs: Image · Output: Masked image

Generates a simple rectangular or oval holdout matte at a specified position and size with edge feathering. Quickly masks out unwanted areas (booms, set edges, rigging) before a keyer or color correction without requiring a full Roto shape.

ParameterTypeRangeDefaultKeys
Shape Enum Rectangle · Oval Rectangle —
Center X Float 0 – 1 0.5 —
Center Y Float 0 – 1 0.5 —
Width Float 0.01 – 1 0.5 —
Height Float 0.01 – 1 0.5 —
Feather Float 0 – 0.3 0.02 —
Invert Bool on / off false —
Example — Masking a microphone boom

Place Garbage Matte before a Chroma Key. Enable Invert and position/size the rectangle to cover the boom in the corner. The keyer now ignores the boom area entirely.

Math

 Absolute

Inputs: Image · Output: Image with absolute value per channel

Takes the absolute value of each RGB channel. Useful for signed displacement maps and difference passes that may contain negatives.

No adjustable parameters.

Example — Show a difference pass as positive magnitude

Subtract two plates with the Math Subtract node, then run Absolute to display the magnitude of the difference instead of the signed value (which would clip negatives to black on a video display).

 Add

Inputs: Image · Output: Image with constant added per channel

Adds a per-channel constant to every pixel. Range spans negative values so it doubles as a "shift down" by entering negatives.

ParameterTypeRangeDefaultKeys
Red Float -2 – 2 0 —
Green Float -2 – 2 0 —
Blue Float -2 – 2 0 —
Example — Lift shadows by a fixed amount

Set Red/Green/Blue to 0.05 to add a small constant to every pixel — useful for raising the floor of a too-dark plate before a grade.

 Divide

Inputs: Image · Output: Image divided by per-channel constant

Divides each pixel by a per-channel constant. Range starts at 0.001 (the schema and kernel both guard against divide-by-zero).

ParameterTypeRangeDefaultKeys
Red Float 0.001 – 4 1 —
Green Float 0.001 – 4 1 —
Blue Float 0.001 – 4 1 —
Example — Unpremultiply by a known matte value

When a colour pass has been baked-in premultiplied by a constant alpha, divide each channel by that alpha value to recover the unpremultiplied colour.

 Max

Inputs: Image · Output: Image clipped below the per-channel floor

Lifts each channel up to a per-channel floor. Pixels above the floor pass through unchanged.

ParameterTypeRangeDefaultKeys
Red Floor Float 0 – 4 0 —
Green Floor Float 0 – 4 0 —
Blue Floor Float 0 – 4 0 —
Example — Eliminate negative scene-linear values

Set R/G/B floors to 0 to clamp any negative values (introduced by signed displacement maps or noisy floats) up to zero, leaving positives unchanged.

 Min

Inputs: Image · Output: Image clipped above the per-channel ceiling

Clamps each channel down to a per-channel ceiling. Pixels below the ceiling pass through unchanged.

ParameterTypeRangeDefaultKeys
Red Ceiling Float 0 – 4 1 —
Green Ceiling Float 0 – 4 1 —
Blue Ceiling Float 0 – 4 1 —
Example — Hard clip highlights to display white

Set R/G/B ceilings to 1.0 to clip super-whites in scene-linear data down to display-white before a Rec.709 export. Pixels at or below 1.0 pass through; brighter pixels become 1.0.

 Multiply

Inputs: Image · Output: Image with per-channel constant multiplier applied

Multiplies each pixel by a per-channel constant. Range spans -4 to 4 — wider than Color Balance — so it doubles as a sign-flip or large-scale gain stage.

ParameterTypeRangeDefaultKeys
Red Float -4 – 4 1 —
Green Float -4 – 4 1 —
Blue Float -4 – 4 1 —
Example — Negate a normal-map Z component

Set Blue to -1 on an OpenGL → DirectX normal map flip. R and G stay at 1; only the Z (Blue) channel inverts.

 Power

Inputs: Image · Output: Image with each channel raised to a power

Raises every RGB channel to the same exponent. Negative inputs are clamped to 0 first to avoid NaN.

ParameterTypeRangeDefaultKeys
Exponent Float 0.1 – 4 1 —
Example — Compress dynamic range with a 0.5 power

Set Exponent to 0.5 (square root) to compress bright highlights and lift dark midtones — useful for previewing HDR detail without a tone-map node.

 Subtract

Inputs: Image · Output: Image with constant subtracted per channel

Subtracts a per-channel constant from every pixel.

ParameterTypeRangeDefaultKeys
Red Float -2 – 2 0 —
Green Float -2 – 2 0 —
Blue Float -2 – 2 0 —
Example — Pedestal removal on a too-bright black

If a plate's blacks read above 0, subtract the offending value from R/G/B equally to bring the black point back to zero before grading.

3D

 Camera

Output: (data) — wire into Render 3D ▸ Cam

Virtual camera defining the view, projection, and output dimensions for a 3D scene. Position is in world units; rotation is XYZ Euler degrees applied in ZYX intrinsic order (the convention every major DCC package uses). Focal length and sensor size define the lens — focal/sensor produce a vertical field of view via the standard lens equation, so users think in physical-camera terms instead of arbitrary FOV angles.

ParameterTypeRangeDefaultKeys
Pos X Float -50 – 50 0 ✓
Pos Y Float -50 – 50 0 ✓
Pos Z Float -50 – 50 5 ✓
Rot X Float° -180 – 180 0 ✓
Rot Y Float° -180 – 180 0 ✓
Rot Z Float° -180 – 180 0 ✓
Focal (mm) Float 8 – 300 50 ✓
Sensor (mm) Float 6 – 70 24 —
Output W Int px 16 – 8192 1920 —
Output H Int px 16 – 8192 1080 —
Track Source Node ref (none) · any Point Tracker (none) —
Track Scale Float 0.01 – 20 1 —
Example — Animate a camera dolly toward a Card

Default Pos Z is 5 with the Card at the origin — the Card is visible on screen. Keyframe Pos Z from 5 at frame 1 to 1 at frame 60 to dolly the camera in over two seconds at 30fps. The Card stays sharp; perspective increases as the camera approaches.

Driving the Camera from a solved track: set Track Source to a Point Tracker that has a solved trajectory; the camera reads its R/t from the trajectory at each frame and your keyframed Pos/Rot are ignored. Use Track Scale to dial in the magnitude of chained translations (Phase 3α doesn't propagate scale between consecutive pair solves — pure-pan shots leave it at 1; dolly shots usually need adjustment to match the real camera distance).

 Card

Inputs: Image · Output: (data) — wire into Render 3D ▸ C1–C8

Textured plane in 3D space. The card is a unit square (1×1 world units) at the origin, facing +Z (so a default Camera at +Z looking back at the origin sees the texture right-side up). Position, rotation, and per-axis scale place it anywhere in the scene. The Tex socket carries the image to map onto the surface.

ParameterTypeRangeDefaultKeys
Pos X Float -20 – 20 0 ✓
Pos Y Float -20 – 20 0 ✓
Pos Z Float -20 – 20 0 ✓
Rot X Float° -180 – 180 0 ✓
Rot Y Float° -180 – 180 0 ✓
Rot Z Float° -180 – 180 0 ✓
Scale X Float 0.05 – 10 1 ✓
Scale Y Float 0.05 – 10 1 ✓
Snap Source Node ref (none) · any Point Tracker with a cloud (none) —
Snap Point # Int 0 – cloud size − 1 0 —
Example — Three layers of matte painting at different depths

Drop three Card nodes, each fed by a different background layer (sky, mid-distance hills, foreground trees). Set their Pos Z values to -10, -5, -2 respectively so they're staggered in depth. Connect them all to a Render 3D node alongside a Camera. As the Camera animates sideways, parallax separates the layers automatically — the foreground moves more than the background, just like a real camera move.

Snap-to-track: set Snap Source to a Point Tracker that has a triangulated cloud (any tracker after Solve Trajectory). Pick a Snap Point # and the card's world position locks to that 3D feature for the entire shot — your keyframed Pos sliders are ignored. Rotation and Scale stay user-controlled, so you can rotate a poster to face the camera or scale it up to cover a larger surface. Combine with a tracked Camera 3D in the same scene for full matchmove.

 Render 3D

Inputs: Camera, Card 1, Card 2, Card 3, Card 4, Card 5, Card 6, Card 7, Card 8 · Output: 2D rendered image at Camera output dimensions

Renders the connected 3D scene to a 2D texture. The Cam socket takes one Camera; the C1–C8 sockets take Card nodes in any order. Cards are depth-tested so overlaps in 3D space sort correctly without manual ordering. Output dimensions and aspect come from the Camera node, not from the input cards. Cards with alpha composite premultiplied-over earlier draws.

No adjustable parameters.

Example — Two-card scene with a moving camera

Wire one Camera into Cam, two Cards into C1 and C2. Place C1 at (0, 0, 0) and C2 at (2, 0, -3) (back and to the right). Animate the Camera's Rot Y from -15 to 15 over the timeline. Render 3D produces a 2D image of both cards in 3D space, with the perspective shift baked in. Pin Render 3D to preview in the viewer; the result feeds downstream like any other 2D image.

More than 8 cards? Chain multiple Render 3D nodes through a Blend (Over) node — render the back set first, then composite the front set over it. Each Render 3D needs its own Camera (with the same params) so the perspective stays consistent across the chain.

7. Tips & Workflows

Keep the graph linear

Apply Log→Lin immediately after every Input node that reads Cineon/DPX log footage, and Lin→Log before export when the delivery requires log encoding. Do all keying, compositing, and color work in linear light — this is the single most important practice for correct results.

Matte inputs restrict effects

Almost every effect node (Blur, Exposure, Color Balance, etc.) has an optional Matte input. Connect a greyscale matte to confine the effect to only the white regions of the matte. Use a Roto shape or a Chroma Key matte as the restricting mask.

Unpremult / Premult sandwich for color corrections

When color-correcting a premultiplied element: chain Unpremult → Color Balance (or Exposure) → Premult. The sandwich ensures the correction is applied to true pixel values without the alpha multiplication skewing edge colors.

Use a mid-shot reference frame for tracking

Setting the reference frame in the middle of a shot (not frame 1) splits the tracking into two shorter sweeps. Accumulated drift is cut in half compared to tracking from the first frame all the way to the last.

Blend modes cheat sheet

ModeFormulaUse for
NormalFG over BG via alphaStandard composite
AddBG + FGLight flares, fire, sparks
MultiplyBG × FGShadow passes, burnt-in effects
Screen1−(1−BG)×(1−FG)Glows, soft light
OverlayContrast boost using bothTexture overlays, grunge
Difference|BG − FG|Alignment checking, stylistic
Minmin(BG, FG)Intersection mattes
Maxmax(BG, FG)Union mattes

Film restoration pipeline

[Input DPX] → [Dustbust] → [Descratch] → [Log→Lin]
             → [Grain (small amount)] → [Lin→Log] → [Output DPX]

Run Dustbust and Descratch in log space (before Log→Lin) so the thresholds match the log-encoded pixel values. Add a small amount of Grain after conversion to re-introduce natural-looking texture after the repair operations smooth things out.

Exporting a premultiplied alpha sequence

For delivery of a keyed element with alpha (for use in another application), set the Output node format to Image Sequence. Connect the Chroma Key or Roto node output directly — the alpha channel is preserved in EXR and PNG image sequences. Do not add a Premult before export unless the receiving application specifically requires premultiplied alpha.