All nodes

LiveRead

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

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.

WriteSmith

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.

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.

CleanPlate

EXPERIMENTAL — still being built. Removes an object by pulling the TRUE background from the frames where it is visible: every masked pixel is filled from other frames warped through a BS_VectorBake, taking a confidence-weighted median so flicker and passers-by drop out. What no frame ever reveals is flagged in the holes matte, never invented -- turn on fill_holes to inpaint it and the matte still says where.

Comp

A whole comp inside one node, like a Houdini subnet or an After Effects precomp. Double-click it (or Enter / I) to open its own node graph; U comes back up. The Output inside is what this node shows. Wire pictures into its pins and an Input node inside picks each one up. Shift+C collapses selected nodes into a new Comp; Explode (in its panel) puts them back.

CompInput

Inside a Comp: delivers what is wired into the Comp's pin (index 1-4) in the network above.

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.

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.

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.

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

Blur

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

Defocus

Nuke's Defocus: defocuses the image with a disc filter — one disc for the whole frame, no depth. Set `defocus` for the disc's radius in pixels, `ratio` to stretch it sideways (anamorphic ovals), `scale` to grow both. Highlights bloom into discs the way a lens draws them. For a defocus that follows depth, use Bokeh.

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.

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.

MotionBlur

Adds directional motion blur — a shutter for moves that don't have one. On footage it solves the motion between this frame and its neighbours itself (Nuke's MotionBlur) and smears along it; after a Transform, MotionVectors or a render carrying motion vectors it smears along those in one pass.

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.

Sharpen

Unsharp-mask sharpening — boosts local contrast at edges.

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

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.

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.

CameraShake

Shake the picture like a camera: pick a preset (Handheld, Walking, Running, Vehicle, Explosion hit, Earthquake) and turn intensity for how far and speed for how fast. hide_edges zooms in just enough that the frame's edge never shows, and motion blur is on. It is a Transform underneath, so it joins the Transforms around it in one resample. The viewer draws the shake's path over the range with a dot at this frame.

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.

HoldFrame

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

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.

Retime

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

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.

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.

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.

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.

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_Advect

Carries a texture or painted layer along the picture's motion: regenerated at keys and cross-faded by distortion (watercolour grain and washes that move with the shot), or each painted frame's strokes carried both ways up to a horizon (paint that smears off the surface). Uses the render's vectors or MotionVectors; solves flow itself when there are none, and says so.

BS_LineArt

Ink lines where the render's id, depth or normal passes step (silhouettes, creases, occlusions - exact, never fooled by a shadow) and hatching along the picture's flow in the dark tones, anchored to the surface. The engraving look over paper; luma_edges draws plates with no passes.

BS_Painterly

Repaints the frame as brush strokes that stay put on the surface: stroke particles seeded from the position pass ride camera moves and deformation without boiling, oriented by the picture's own flow, sized by distance, painted far to near. Cadence (on twos) and a rationed boil are the artistic time controls.

Canvas

The blank sheet: paper of a colour (or nothing) at a size, with a touch of grain. Opening the Atelier with nothing to paint on makes one at the project's format with a PaintOver after it - the Procreate start.

CoherentNoise

Noise that tracks the world: sampled in world space through the position pass, so grain, paper and jitter stay stationary on the surface across a camera move instead of sliding on the glass. A noise layer for other nodes, or applied as grain directly.

ObjectApply

Texture to screen, every frame: gathers a bake back through this frame's UV pass, re-matted by its cryptomatte, and composites it over the stream - the node that makes paint ride the shot through camera moves and deformation.

ObjectBake

Screen to texture: bakes the upstream PaintOver's object-anchored strokes through each painted frame's UV pass into per-object textures (one per UDIM), seams filled and dilated, written beside the project for the comp and for Unreal. Says when the bake is stale.

PaintOver

The Atelier's canvas: paint over a rendered frame with strokes that stay strokes (re-bakeable, one undo each), scoped to an object by its cryptomatte. Checks the render delivers what painting on the object needs - a UV pass, unfiltered, tagged as data - and says so on the node when it does not.

BS_Damage

EXPERIMENTAL — still being built. Procedural damage on a surface — cuts, tears, frays, worn holes, squib hits, metal gashes — where the roto says. Wire the plate into `in` and a roto into `cut`: its shape IS the damage (the node never invents a location; it gives the artist's shape a material edge). `matte` bounds the surface so fray and threads stay on the garment; `under` is what shows through. The output is the plate with the damage on it; the views (`damage.hole/fray/threads/lip/debris/reveal`) ride along as layers. Twist `torn` and `age` for severity, pick a material preset from the strip, then tune the fine knobs.

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_HoloBuild

BS_HoloBuild: the holodeck — an object drawn as a hologram of lines and panels that then materialises into the real thing, or a hologram that reveals what is behind it, or a transition where A powers down, the void opens and B is built and lands. Built from a 3D scene node or from B's render passes (depth, P, N, uv, cryptomatte), drawn through the project camera, with a floor grid and a room, the subjects kept solid and lit by the hologram's spill, and the instabilities (flicker, shimmer, scan bands, chroma offset) that make it read as projected light. Nine presets. Every beat is on the clock knobs, in frames.

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.

Kiln

EXPERIMENTAL — still being built. Kiln: a gas simulation that lives in the 3D scene — smoke, fog, steam, dust — solved on a brick grid inside a box you place, emitted from a shape, lit by the scene's lights and drawn through the project camera like any volume. It is a Scene node: view it in the 3D viewport or render it with Render3D; the density and temperature grids ride the same path a VDB file does, so VolumeShade, the depth holdout and the AOVs all apply. Live it simulates on demand up to 240 frames past the last frame it has; heavier shots bake to VDB with ⚒ Bake and play from disk. Colliders (a placed box or sphere, or any scene mesh — imported, animated, deforming) go in its network and hold the gas back; a sim with one runs on the CPU reference until the GPU twin learns solids, and the panel says so. The CPU solver is the reference; the GPU port is what makes it realtime.

KilnRender

EXPERIMENTAL — still being built. The Kiln gas as a 2D node: Read → KilnRender → Merge. It owns its own sim (the same knobs as Kiln) and renders it through `camera` over the plate wired to `plate`, in the plate's format, the render composited over the plate the way Render3D composites over its bg. `matte` makes a roto or a Crucible matte the emitter; `depth` (or the plate's own depth layer) holds the gas out behind what the plate already has in it; `aov` adds the data layers. Select it and the 3D viewport shows the gas being rendered while the viewer shows the render.

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.

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

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.

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.

DepthConform

Say what a depth pass IS, once, and turn it into Forged depth (Z along the view axis, world units, the sky at infinity). Everything downstream then reads one convention; a Fathom node that meets anything else refuses with the reason instead of making halos. Presets for Unreal SceneDepth, Nuke 1/Z, Blender and Maya.

Fathom

Depth for any plate, the Depth Anything way and better: ⚒ Analyze estimates depth with a commercial-use model on the GPU, puts it in the tracked scene's metres when a CameraTracker is wired to `camera`, steadies it over time, and snaps it hard at edges so depth merges and defocus get no halos. Outputs the plate plus depth, depth_soft, depth_conf, depth_sky, N and P. Wire a matte to make a subject one clean depth layer.

FathomMatch

Put an element in the plate's air and focus at the element's own depth: Koschmieder haze (so a blue haze is blue) and thin-lens defocus. ⚒ Fit from plate measures both from the plate and draws the data it fitted, so the numbers are something to look at; every value stays a knob.

FathomMerge

Composite elements by depth, per pixel: every input carries depth (a Fathom plate, a Render3D, a placed element, Unreal CG through a DepthConform) and each pixel is sorted near to far - DeepMerge without a deep workflow. Alpha carries the antialiasing and depth the surface, so there are no halos. Outputs the result, the nearest depth, and each input's visibility (fathom_vis_<input>).

FathomPlace

Put an element into the shot in depth: click where it stands (the green foot in the viewer) and give its real height, and it is scaled by true perspective, sits on the plate's surface, and carries its own depth - so in a FathomMerge whatever of the plate is nearer hides it, with no roto. It arrives already in the shot's air and focus (match) and casts a shadow onto the plate (shadow). Wire the element into `element` and an analysed Fathom into `plate`.

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.

Axis3D

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

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.

CloudMesh3D

Meshes a solved point cloud into a proxy: triangulates through the solve camera's view (Nuke's PointCloudGenerator meshing), keeps the cloud's plate colors as vertex color. One click after a solve gives a ground/set mesh for shadows, projections and layout.

Display3D

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

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.

FitPlane3D

Fits a plane through cloud points and lands it as a real card, snapped to the world — how proxy walls and floors get built. RANSAC ignores stray points, so on a ground-heavy solve it works with no knobs touched; give it a selection to fit one wall.

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 drawn as a flat dot of constant pixel size, colored by the plate. Scene+ creates one; snap cards and geometry to it, or mesh it with CloudMesh3D.

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.

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.

Scene3D

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

SplatDissolve

Dissolves splats away — the effect node for reveals, disintegrations and hologram assembles. A FIELD decides the order: `sweep` runs from your placed ▶ start point to your ⏹ end point (click them in the 3D viewer), `noise` sizzles everywhere at once, `distance` grows from the start point outward, `axis` wipes along X/Y/Z, `matte` projects a 2D matte through a camera and dissolves what it covers (a Roto or Crucible key eating a capture — the cross-system trick). Keyframe `progress` 0→1 to play the effect; `shrink` makes splats evaporate instead of ghosting. A Directed region (box/sphere) limits it to one object. Chain several with different fields and regions for multiple effects on one capture.

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.

SplatShade

Grades splats in 3D — a tint and gamma on the capture's base colour, optionally limited to a region so one object grades without touching the scene. For lighting-level control (dynamic lights, ambient, exposure) use the SplatRead's Relight section; this node is the quick colour nudge in the chain.

SplatTransform

WHERE YOU EDIT a splat capture — the first node after every SplatRead. Move/rotate/scale the whole set (Transform section), keep only a region or carve one away (Crop — box or sphere, feathered into a soft opacity falloff), and clean up (floater removal for the debris clouds every capture has, opacity floor for near-transparent junk). Edits apply in panel order — transform first, so the crop reads in the placed position. Chain more SplatTransforms for more edits; the effect nodes (SplatDissolve, SplatWarp, SplatShade) go after.

SplatWarp

Pushes splats around — drift, wind, swirl, scatter. On the default `sweep` field the push blows from your placed ▶ start point toward your ⏹ end point (click them in the 3D viewer) — wind you can aim by clicking twice. `noise` swirls everywhere; `distance` pushes away from the start point (explode) or, negative `amount`, pulls toward it (implode); `axis` shears along X/Y/Z. `amount` is the push in metres — keyframe it to animate. A Directed region limits it to one object. Warped splats emit motion, so they blur correctly in the 2D comp.

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_AdditiveKey

The hair-detail trick, packaged: plate minus screen colour, desaturated, gained, ADDED over the comp - weighted to the screen area so the body never doubles up. Nothing is cut, so wisps, motion blur and flyaways survive the key. Wire the assembled comp into `in`, the original plate into `plate`, eyedrop the screen.

BS_LightWrap

The background's light bleeding around the keyed foreground's edge - the node every keying tutorial hand-builds from a Blur, an edge band and a Merge. Wire the keyed FG into `in`, the BG into `bg`, place it before the final merge over.

Backdrop

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

Bokeh

Nuke's Bokeh node, knob for knob: the depth-driven lens defocus. The stream's depth channel sets each pixel's circle of confusion around the focal plane — from a real lens (focal length, f-stop, film back) or from a multiplier — with a focus region, front and back regions with their own amounts, a kernel that is a circle, an iris of curved blades or an image, bloom and aberrations, corrective depth slices so near blur covers far, and five output types. Wire depth-carrying footage (EngineLive, a Render3D pass, an EXR with a Z layer); without depth the image passes through and the node says so. For a flat 2D disc blur, use Defocus.

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.

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.

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.

MotionVectors

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

Output

Marks a branch's deliverable end-point. Inside a Comp, the Output is what the Comp shows in the network above.

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.

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.

StickyNote

A paper note pinned to the graph — write yourself (or the next artist) a message beside the work. Drag to place, drag the folded corner to resize; text and colour live in the panel.

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.

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.

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.