All nodes

Read

Brings footage into the comp: stills, ####-numbered sequences, EXR/DPX/PNG/JPEG/TIFF, and video via ffmpeg. The colorspace knob linearizes the file into the working space.

Viewer

Shows a branch. Nine numbered inputs — press 1–9 over the graph to wire and view; the display transform is view-only and never changes pixels.

Write

Renders the comp to disk: EXR/DPX/PNG/JPEG sequences, or a video file (.mp4/.mov/.webm - ffmpeg encodes the range at the project fps). The colorspace knob encodes for delivery on the way out.

Copy

Copies channels from A into B — classically the matte into the beauty before Premult.

Dissolve

Crossfades between two inputs.

Dot

A wire elbow. Keeps the graph tidy; does nothing to the image.

FKeep

Keeps only the listed layers; everything else is pruned from the stream (and never computed upstream).

FRemove

Drops the listed layers from the stream; everything else passes through.

MaskedMerge

Combines two mattes: max (union), min (intersect), minus (subtract). The matte-assembly node.

Merge

Composites A over B (and more operations: add, screen, multiply…). B is the base and decides the format; extra A inputs stack.

Switch

Chooses one of its inputs by index — version switching, A/B trees.

Add

Adds a value to every pixel. Lifts blacks; a building block.

Associate

Multiplies RGB by alpha. Do it after Copy'ing a matte in, before an over.

ChannelRoute

The channel patch bay: route any layer's channels — from either input — into any output layer. Constants 0/1 fill; typing a new output layer declares it. Wiring, not math.

Clamp

Limits values to a range — kill negative pixels or super-whites before an op that can't handle them.

ColorCorrect

Colour correction in zones: master, shadows, midtones and highlights each get their own saturation/contrast/gamma/gain/offset — grade the tones separately.

ColorCurves

Per-channel curves — click to add points, shape the response exactly. The surgical grade.

ColorGrade

Lift / gamma / gain grading in the classic three-way style — shadows, mids, highlights as colour wheels.

ColorSpace

Converts between colorspaces mid-graph. Use sparingly: the graph should stay scene-linear; this is for special pipelines.

CurveLUT

A lookup curve applied per channel — remap input values to output values point by point.

Exposure

Exposure in stops — one knob, photographic. +1 doubles the light.

FileLUT

Applies a LUT file from disk (.cube, .spi) — a camera LUT or a show look.

Gamma

A gamma (power curve) adjustment. Brightens or darkens midtones without moving black or white.

Grade

The workhorse colour tool: blackpoint/whitepoint set what maps to black and white, then lift/gain/multiply/offset/gamma shape the result. Whitepoint-sample the plate's white, then balance.

HueCorrect

Per-hue correction curves — desaturate just the greens, darken just the blues. The spill-and-sky tool.

HueShift

Rotates hue around the colour wheel. Shift a costume, tune a sky.

Invert

Inverts the image (1 − value). Mattes flip; colour goes negative.

Multiply

Multiplies every pixel. Scales brightness; on a matte, scales opacity.

Saturation

Scales colour saturation. 0 is grayscale, 1 unchanged.

SoftClip

Highlight rolloff: values above the threshold compress smoothly toward max instead of clipping hard — speculars keep gradation, nothing exceeds the ceiling.

Unassociate

Divides RGB by alpha — undo premultiplication before grading, re-Premult after.

Blur

A box blur. Size is the radius in pixels; use the mask input to blur selectively.

Defocus

Depth-driven lens defocus: the stream's depth layer (UnrealLive/Render3D aux plane) sets each pixel's circle of confusion around the focus distance. Out-of-focus foregrounds halo over the focal plane; in-focus subjects keep crisp edges.

Despot

Removes small speckles from a matte — fills pinholes in the core, kills islands in the background.

DirectionalBlur

A streak along an angle: speed lines, faked motion on a still. Centered, energy-conserving; MotionBlur is the temporal shutter, this is the spatial one.

EdgeBlur

Blurs only the matte's edge, leaving core and background solid.

Erode

Shrinks (positive) or grows (negative) a matte. The choke: pull a key's edge in by a pixel or two.

Glow

Adds a soft bloom around bright areas. Threshold picks what glows.

Grain

Adds synthetic film grain — match a plate's texture on clean CG.

Median

The rank filter: each pixel becomes its neighborhood median. Fireflies and hot pixels die; edges survive exactly — the pre-key cleanup a blur can't do.

Sharpen

Unsharp-mask sharpening — boosts local contrast at edges.

CleanScreen

Builds a clean plate of the backing screen from the shot itself — feed it to KeyerScreenClean.

EdgeFill

Pushes edge colours outward past the matte edge, so soft edges and blur pull real colour instead of black.

EdgeLight

Wraps background light around the foreground's edges — the optical halo that sells a composite.

Keyer

A luminance/channel keyer: pulls a matte from brightness or a chosen channel. For skies, windows, and simple extractions.

KeyerChroma

A chroma keyer: pulls the matte by distance from a sampled screen colour in chroma space.

KeyerML

A learned matte: the model estimates foreground coverage. For hair and edges where samplers struggle; refine with the classic keyers.

KeyerSample

The sample-driven keyer: arm 🎯 in the panel, Ctrl+click the viewer — screen samples say what leaves, foreground samples say what stays. Chroma-space distances key an unevenly lit screen from a few clicks.

KeyerScreen

The screen keyer: sample the green/blue backing, get a matte plus despilled RGB. The daily green-screen tool.

KeyerScreenClean

Image-based keying: uses a clean plate of the empty screen to key uneven backings — the tool for badly lit screens.

SpillKill

Removes green/blue spill bounced onto the subject, keeping luminance. Run it on the fill, separate from the matte.

AdjustBBox

Grow or shrink the data window by whole pixels without touching content — bbox hygiene for filters that read past the frame and merges that shouldn't.

CameraTracker

Solves the 3D camera from the footage (matchmove): auto-tracks hundreds of points, reconstructs the camera path + point cloud + lens, and bakes them as keyed animation. Detects nodal pans and planar scenes automatically.

Crop

Cuts the image to a box and (optionally) reformats to it.

FourCorner

Maps the image onto four corners — screens, signs, posters. Track the corners, pin the insert.

GridWarp

A lattice of control points you drag in the viewer; the image follows as a smooth Catmull-Rom patch. Corners pinned, mix fades the warp - beauty warps, plate squeeze, quick cosmetic fixes.

LensDistort

Applies or removes lens distortion. Undistort, comp straight, redistort — the matchmove round trip.

Mirror

Flips the image horizontally or vertically.

PinWarp

Pairs of pins: drag a dot and the image follows it, smooth in between (moving least squares). Ctrl+click adds a pin, Alt+click removes; the ring is what moves, the dot is where it goes. Anchor pins hold regions still.

QuadTracker

Tracks four points as a plane — feeds CornerPin for screens and signs.

Resize

Changes resolution: to the project format, a named format, or by scale. This is resizing; Transform is placement.

SplineWarp

Correspondence splines: draw a curve on a feature and the curve where that feature should end up, and every pixel between follows. Ctrl+click adds a point to the current spline (Ctrl+Shift starts a new one), Alt+click removes one; the ring line is the source, the solid line is the destination. `pin_border` holds the frame edge still so one curve cannot drag the whole plate after it. Under the hood these are the same moving-least-squares controls PinWarp uses, sampled along both curves at matching arc length — so a stretched curve still matches its partner.

Tracker

Tracks 2D points through the shot: place a pattern box, track, then drive a Transform or stabilise. Adaptive tracking with a confidence readout.

Transform

Move, rotate, scale and skew the image around a centre. Concatenates with neighbouring transforms so filtering happens once.

Crucible

The matte engine: comp-grade mattes with true float alpha, for hair, motion blur and soft edges. Arm ✛, click the subject in the viewer (Alt+click to push a wrong region back out), then 🜛 Analyze — it identifies at every frame you clicked, propagates across the range, mattes the edge, and takes the old background's colour out of it. The matte lands in alpha and on its own crucible channels; RGB is untouched. It will not guess: with no clicks it does nothing and says so. ⟲ To Roto turns the result into an ordinary Roto node when you want to take over by hand.

CrucibleRefine

Matte finishing for ANY alpha — a keyer's, a roto's, an imported matte, or one Crucible made. Clean the haze out of black and white, feather or sharpen, tighten contrast, shift the edge, grow or erode just the solid core. Shift Edge is the one to know: it translates the soft profile along its own gradient instead of eroding, so nudging a feathered edge keeps the falloff you spent time on. Every knob is a no-op at its default.

Paint

Brush strokes over the image: paint stamps color, clone stamps pixels from a Ctrl+clicked source point - wire removal, print cleanup, quick fixes. Strokes commit on release, one undo each.

Radial

A radial (circular) gradient. Quick vignettes and soft circular mattes.

Rectangle

A rectangle shape generator with softness — a quick garbage matte or slate panel.

Roto

Draws animated shapes for mattes: bezier and B-spline, per-point feather, per-shape lifetime and transform. The paint-by-hand matte.

BS_ChromaBlur

Blurs colour and leaves luminance alone. The eye resolves luma far more finely than chroma, so sensor colour noise, compression blocks and blue-screen mottling all die here at no visible cost to sharpness.

BS_DayToNight

Day-for-night that reads as night, not as a dark blue day. Moves the white point toward moonlight instead of tinting, simulates the Purkinje shift (rods desaturate warm hues faster than cool ones as light falls), and protects practical lights from the exposure drop so lamps stay on and warm. Every analysis matte is viewable from the view dropdown — it is never a black box.

BS_Disintegrate

Mask-driven disintegration, automatic and modular: wire the plate and a subject alpha, set start + duration (or key `progress`), pick the front (directional / edge-in / core-out / blotch / spread) — the body erodes behind an organic front, chunks tear off and tumble, dust drifts away in the body's own colours, a hot rim glows, and the background is revealed (a wired bg, else an inpaint estimate). Every stage is its own output layer for grading.

BS_EdgeBreakup

The "CG is too perfect" fixer: procedural texture breakup on surfaces and along mattes. Unlike a plain noise×matte (which fades the noise out exactly at the edge), the invert→merge-from→clamp structure keeps edge detail defined. Wire a position pass and switch to world space and the breakup sticks to the surface as the object moves — tracking for free.

BS_EdgeExtend

Pushes edge colour outward smoothly — as far as you like, up to filling the whole frame. Blacksmith's answer to the dilate-based extends that streak and die after a few dozen pixels. Use before a defocus (so it drags colour, not black), to fill depth-pass holes, or to extend despilled edge colour. Alpha is never touched.

BS_ExpoGlow

Bloom that behaves like a lens: many octaves of scatter summed with an exponential falloff — tight core, wide halo, wider veil — instead of one gaussian. The bright-pass stays scene-linear so an HDR highlight glows in proportion to how bright it really is, and the result is added rather than screened, because light sums.

BS_FireflyKill

Removes path-tracer fireflies — single pixels that won the sampling lottery and landed orders of magnitude too bright. Statistical, not a blur: a pixel is replaced only when it is wildly brighter than the median of its neighbours, and the fix keeps its hue so you don't get a grey dot.

BS_HeatHaze

Animated refraction shimmer — heat off tarmac, exhaust, underwater. It displaces rather than blurs, so the image stays sharp and simply arrives from slightly the wrong place. rise biases the motion upward, which is what makes it read as heat instead of water; evolution animates it so it crawls rather than boils.

BS_HueQualifier

Pulls a matte by colour the way a colourist does: three soft windows — hue, saturation and luminance — multiplied together, so a colour qualifies only if it satisfies all three. The selection is drawn ON the spectrum bars, so you see what you're taking. Drag to move the centre, Shift+drag for width, Alt+drag for falloff.

BS_MasterColor

The whole colour page in one node: balance, tonal wheels, contrast about a pivot, mixer, saturation and hue, six vector zones, curves and a qualifier — in a fixed order, because the order is the craft. One node because a grade is one thought.

BS_MotionMatte

Forges mattes of everything moving independently of the camera — the CameraTracker's subject detector as a standalone node. ⚒ Analyze tracks the shot, finds the movers, and refines dense-flow silhouettes; the result flows downstream as matte / matteId channels for garbage mattes, holdouts, and per-subject grades.

BS_RoughenEdges

Breaks a matte's edge into an organic contour with fractal noise — torn, corroded or wind-wobbled instead of drawn. erode eats bites out of the edge; distort wobbles it without losing area. evolution animates it so it crawls rather than flickers, and the core stays solid.

BS_VectorBake

Analyses the plate once: dense vectors at frame distances 1..64, forward and back, each with a baked CONFIDENCE plane (Nuke bakes none), written to EXR beside the project. Wire an optional matte to exclude a subject. Then warp anywhere with BS_VectorWarp.

BS_VectorWarp

SmartVector-class propagation: pick a reference frame, paint on it, and this carries the patch to every frame through the bake — routing on confidence around bad flow, composing ONE map, filtering once. Wire a matte and the route is judged over THAT region only. Outputs warped / stmap / confidence / error (the round-trip heatmap: green comes home, red slips, blue left frame — read it BEFORE painting to pick the reference frame). Occluded pixels hold and fade instead of smearing; `untrackable` marks spans the solver must hop over rather than walk through; `edge` says whether a route leaving the plate fades (default) or drags the border in. List several frames in `references` and each pixel takes whichever route was most confident — the keymix rig Foundry's own docs tell you to build, in one node; the `winner` view colours who owns what.

BS_PinTool

Places a 3D model against a frame by pinning it: click points on the model, drag them where they belong in the image, and the solver finds the pose. One pin slides it in the image plane; two add scale and roll; three or more give full rotation — and the panel tells you which. The foundation of the Anvil tracking suite.

Checkerboard

A checkerboard generator — for checking transforms, aspect, and filtering.

ColorWheel

The colour wheel test pattern: hue around, saturation outward, `value` for brightness — judge any colour tool against it.

Constant

A solid colour at the project format. The everyday background, slate, or matte-filler.

Noise

Procedural noise. Grain stand-ins, displacement sources, texture breakup.

Ramp

A linear gradient between two points. Vignettes, sky grades, matte falloffs.

Text

Draws text — slates, burn-ins, version stamps.

HoldFrame

Freezes one frame — reference stills, clean-plate holds.

MotionBlur

Adds directional motion blur — a shutter for moves that don't have one.

Retime

Speeds footage up or slows it down. Frame-blending optional.

TimeEcho

Combines the frame with decaying copies of past frames - light trails, stutter ghosts, energy tails. max keeps the brightest trail, average softens, plus stacks.

TimeShift

Shifts the clip in time by a fixed number of frames.

Backdrop

A labelled, tinted panel behind nodes — organise the graph into districts.

Group

A collapsed set of nodes behind one tile (Ctrl+G on a selection; double-click opens). Promote member knobs in the panel to drive the inside from the group. Ctrl+Shift+G dissolves it; the graph underneath stays flat and simple.

LiveRead

A live source: frames pushed from a running DCC (Unreal, the feeder) appear here and update the comp automatically.

Precomp

Freezes the branch above it. Bake renders the input to an EXR sequence; while baked, upstream never cooks (edit or even delete it freely) and downstream reads the files. Un-bake to go live again; the panel flags a stale bake.

ViewportFX

The 3D viewport as a live 2D source: every viewport render streams into this node, so a chain wired downstream (grade, glow, defocus) recooks live while you navigate. View the chain's tail in a 2D viewer.

Axis3D

A 3D null/locator — a parent transform other things can follow.

BS_GeoTracker

Tracks a MODEL through a shot: wire the plate and the geometry, place it on the anchor frame, and it solves the object’s motion frame by frame, holding the mesh on the subject. The correction workflow is the point — grab a pin on any frame, nudge it, and the solve re-fits around what you stated. Feeds projections, textures (TextureBuilder) and matchmoved renders.

Camera3D

A camera in the scene: position/rotation plus film-back (focal, aperture). Render3D renders through it; the viewport shows its frustum.

Card

A plate standing in 3D: an image on a quad at its own aspect. `file` takes a file path — or the NAME of a 2D node to show that branch live.

Display3D

Overrides how prims draw in the viewport (wireframe, points, bbox…) without touching the render.

GeoPrimitive

A geometry primitive (cube, sphere, plane, cylinder) with transform and colour — stand-ins and simple set pieces.

Light3D

A light in the scene — point, spot, distant (sun), rect, or dome (ambient). Authored as a standard UsdLux prim, so the viewport, Render3D, USD export and the Unreal bridge all read the same light. Zero lights in a scene = the neutral headlight rig.

Merge3D

Combines 3D branches into one scene.

ParticleSystem3D

A deterministic particle system: sparks, dust, rain, embers. Emits from a point, card, sphere or box; gravity, drag and curl-noise turbulence move them; size and colour ramp over each particle's life. The sim is bit-identical every time — the same seed and frame give the same answer whether you played there or scrubbed there, so a re-render is a re-render. Particles are authored as a standard USD Points prim, so they carry velocities and per-particle ids for motion blur and id passes.

PointCloud3D

A solved camera track's 3D point cloud: each tracked feature's reconstructed position as a small marker. Scene+ creates one; snap cards and geometry to it.

Project3D

Camera projection - the matte-painting workhorse: throws an image from a Camera3D onto target geometry (a subdivided Card, a mesh). Freeze the camera on one frame to patch; move the render camera and the projection sticks to the surface.

Prune3D

Hides or deactivates prims by path — trim the scene without deleting nodes.

ReadGeo3D

Reads geometry from a .usda or .obj file into the scene.

Scene3D

The root of a 3D branch — an empty stage other 3D nodes build on.

SplatFx

Directs a gaussian-splat capture with a FIELD over its splats (spec §5) — the difference between a viewer and comp. crop: keep or carve a box/sphere region, feathered into a soft opacity falloff (splats feather beautifully). dissolve: fade opacity by a noise/distance/axis field, optionally shrinking splats to nothing (the assemble-the-hologram look). warp: push splats along a field — swirl, drift, wind. shade: tint + gamma the base colour. matte: project a 2D matte (a Roto, a Crucible key, any branch) through a camera and dissolve the splats it covers — the cross-system trick nothing else can do. Dissolve/warp/shade take an optional REGION (box/sphere) so the effect hits one object, not the whole scene. Chain several; each appends to the set. Cleanup (floater removal, opacity floor) lives on the SplatRead node.

SplatRead

Reads a gaussian-splat capture (.ply in the 3DGS layout, .splat, or .spz) into the scene: a captured location as millions of soft elliptical blobs, with parallax and view-dependent colour. Loads off-thread — the box draws dim while streaming, then the splats render in the viewport and Render3D, sorted and alpha-blended, depth-composited against cards and geometry. `color_space` declares what the trainer baked (sRGB is usual; a washed-out or crunchy capture is almost always this knob). `budget` caps drawn splats by importance and SAYS so in the HUD. `cluster_tolerance` sets the spatial cluster size used for crypto ids, groups and normal smoothing (0 = automatic). RELIGHT (§4): `relight`=lights turns on the dynamic Light3D loop — `ambient` dims the capture-day lighting baked into the splats and the scene's lights add your own key/fill/rim on top (`light_gain` scales them, `exposure` in stops scales the whole). This is relighting a captured location, which no other compositor does. CLEANUP (§5.4): floater_removal drops the debris clouds every capture has (a statistical outlier pass — the raw scene bounds are usually dominated by them); opacity_floor culls near-transparent splats.

Transform3D

Transforms 3D geometry: give it target paths (or leave empty for everything upstream) and TRS.

VDBRead

Reads a .vdb volume cache (smoke, clouds, fire from FX or a bought pack) into the scene as a standard UsdVol prim. Loads off-thread — the box draws dim while streaming, bright when ready. Rendering the volume itself lands with the volume pass; today you get the placed, pickable bounding box.

VolumeShade

The volume LOOK, separate from the read so one look feeds several VDBReads: density scale, scatter colour, anisotropy (forward/back scattering), emission (fire), self-shadow strength. Without one, VDBRead shows neutral grey smoke.

BS_Relight

Relights a plate from its own passes: screen-space lights (a directional sun by azimuth/elevation, or a point light at a pixel with depth) shaded against the ingested normal/roughness/basecolor, with real Light3Ds usable through `lights`. Chain several in add mode to build a key/fill/rim. Needs a PBRIngest upstream — it says so when it has nothing to shade.

Cache

Pins this branch's result in the cache — cook once, reuse while you work downstream.

CatcherComp

The canonical shadow-catcher merge: CG (rendered with the catcher held out) over plate × (1 − caught shadow). Wire your plate in, point `slot` at a catcher-enabled render, and the CG lands with correctly colored, soft shadows. `shadow_density` grades the shadow itself.

ChannelMerge

Combines a channel from A with B by operation — matte maths across streams.

Cryptomatte

Pulls clean anti-aliased object mattes from a cryptomatte render pass: type object names (comma-separated) and the summed coverage becomes the matte — true partial coverage at AA/motion-blur edges, unlike hard ID mattes. `preview` shows the classic random-colour segmentation.

Denoise

Wavelet denoiser: measures the noise (Analyze, or box a flat patch), then removes it per frequency band and channel. Chroma takes more than luma for free.

EngineLive

The live Unreal session as a comp input: the streamed viewport (scene-linear, pre-tonemap) plus aligned depth/id channels where the stream carries them. The comp re-cooks live as the level or camera changes out there. Turn the 3D viewer's LIVE on to feed it.

EngineLook

The engine look as a node on scene-linear input: exposure (stops) then the tonemapper 2014 UE Filmic (the fitted ACES curve UE ships), AgX, or Hable. This is how a render looks IN Unreal while every pixel underneath stays gradeable. none = bypass.

EngineRender

The offline/finaling render against the live session: drives Unreal's Movie Render Queue (Path Tracer for the hero look) and streams high-quality frames back progressively. Rendered frames cache and scrub; unrendered frames show black. Render/Cancel live in the Scene Graph panel's RENDER QUEUE while LIVE is on.

FDenoise

The render denoise stage: a guided filter steered by the albedo/normal/depth passes, so path-traced noise averages away while real edges stay sharp. Point slot at the render; strength blends, radius sets the window. Data passes are never touched.

FilterErode

A sub-pixel erode/dilate with a soft filter — finer control than whole-pixel Erode.

FreqSep

Splits the image into low (colour/shape) and high (texture/detail) bands, and recombines exactly. Beauty and cleanup work happen between the two.

GradeMatch

Solves a grade that makes this image match a reference — automatic colour matching between plates.

MotionVectors

Computes optical-flow motion vectors between frames, for VectorBlur and retiming.

Output

Marks a branch's deliverable end-point.

PBRIngest

Canonicalises a relighting asset\'s PBR passes: takes a vendor\'s basecolor / normal / roughness / depth naming (Beeble’s SwitchLight, render AOVs, or already-canonical layers), linearizes what needs it, decodes packed normals, and hands BS_Relight one predictable set of layers. The preset is RECORDED, so a project opened in a year states what it assumed.

Reassemble

Rebuilds the beauty from the render's AOV split passes with per-term gains — regrade LIGHT, not pixels: indirect ×1.2, key light ×0.7, re-summed. Defaults reproduce the beauty exactly (the reassembly guarantee). Point `slot` at the same render as your EngineRender node.

Regrain

Puts the plate's OWN grain back on comped work: measures it from the plate and re-applies it per-brightness. Better than synthetic grain when you have the plate.

Render3D

Renders a 3D scene into the comp: point `scene`/`camera` at your 3D branch and a Camera3D, and the CG composites over the bg input as a premultiplied element. `aux` adds depth/N/P/id channels.

SplitAOVs

The AOV rebuild, materialized: wire a multilayer EXR in, hit Build comb, and get the classic hand-built web — one ChannelRoute + grade slot per beauty pass, a plus-merge cascade back to the beauty, data passes (N/P/depth/crypto) parked on their own rail. Ordinary nodes, one undo. The preset picks the vendor naming (auto-detected and recorded).

UVWarp

Warps the image by a UV map: each output pixel reads where the map's red/green says. Lens grids, ripples, any baked warp.

VectorBlur

Blurs along motion vectors — real per-pixel motion blur from a MotionVectors pass or a renderer's vectors.