- 
        
            
        
        
            
                Auto Stereogram
            
        
        
            Generates an image with a 3D illusion.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Bake Geometry Textures
            
        
        
            Generates textures by baking between a low-resolution and high-resolution mesh at interactive speeds.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Bend
            
        
        
            Curves images using handles or a captured region.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Blend
            
        
        
            Blends two layers together.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Block Begin
            
        
        
            Start of a block, containing its inputs.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Block End
            
        
        
            End of a block, declaring its outputs.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Block to Geometry
            
        
        
            Compiles a block and produces its geometry representation.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Blur
            
        
        
            Applies a blur to a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Bokeh
            
        
        
            Creates a Bokeh effect by expanding each pixel by an aperture shape.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Bounding Rectangle
            
        
        
            Finds the bounding rectangle of a mask.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Bright
            
        
        
            Brightens a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Bubble Noise
            
        
        
            Generates bubble noise.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cable Filter
            
        
        
            Removes empty wires from a cable.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cable Merge
            
        
        
            Combines two cables into one cable.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cable Pack
            
        
        
            Combines input layers into a cable.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cable Rename
            
        
        
            Renames a cable’s wires based on filters.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cable Sort
            
        
        
            Sorts a cable’s wires by name.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cable Split
            
        
        
            Splits a cable based on filtering parameters.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cable Switch
            
        
        
            Selects an input cable.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cable Unpack
            
        
        
            Extracts individual wires from a cable.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cache
            
        
        
            Caches the input layers for faster playback.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Camera Import
            
        
        
            Creates a layer in a camera’s space.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Camera Properties
            
        
        
            Adjusts the camera properties of a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Channel Extract
            
        
        
            Extracts a channel from a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Channel Join
            
        
        
            Combines multiple Mono layers into one multichannel layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Channel Split
            
        
        
            Divides a layer’s channels into Mono layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Channel Swap
            
        
        
            Swaps channels within a multichannel layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Checkerboard
            
        
        
            Creates an alternating checker pattern.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Chladni Cymatic Patterns
            
        
        
            Generates interference patterns that represent various vibration modes.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Chroma Key
            
        
        
            Keys an input based on hue, saturation, and luminance ranges.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Chromatic Aberration
            
        
        
            Adds chromatic aberration to your image.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Clamp
            
        
        
            Clamps an input layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cloud Noise 3D
            
        
        
            Generates a billowy cloud noise.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Color Correct
            
        
        
            Adjusts colors in the image.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Combine Layers
            
        
        
            Combines all input layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Combine Normals
            
        
        
            Blends two normal maps together.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Compare
            
        
        
            Creates a mask by comparing two layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Constant
            
        
        
            Initializes pixels to constant values.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Contact Sheet
            
        
        
            Arranges input layers into a contact sheet.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Contrast
            
        
        
            Applies contrast to a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Convert Depth
            
        
        
            Converts depth layers between height, depth, and distance.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Convert Normal
            
        
        
            Converts normal layers between signed and offset.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Convolve 3×3
            
        
        
            Convolves a layer by a 3×3 kernel.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Copy and Transform
            
        
        
            Copies stamps and applies transformations to the copies.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Corner Pin
            
        
        
            Pins a layer’s corners in a reference layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Crop
            
        
        
            Crops a layer to a new size.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cross Product
            
        
        
            Performs a cross product of two RGB layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cryptomatte
            
        
        
            Builds a matte from cryptomatte layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cryptomatte Decode
            
        
        
            Decodes a cyrptomatte into coverage and ID.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Cryptomatte Encode
            
        
        
            Encodes a coverage and object hash into a cryptomatte layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Crystal Noise
            
        
        
            Generates a sharp and angular Worley noise type.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Crystal Noise 3D
            
        
        
            Generates a sharp and angular Worley noise type from 3D locations.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Curvature
            
        
        
            Computes the curvature of a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Curve 3D
            
        
        
            Lets you interactively draw Bézier curves using tools similar to 2D illustration programs, as well as polylines and NURBS.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Defocus
            
        
        
            Defocuses an input layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Denoise AI
            
        
        
            Denoises an input layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Denoise TVD
            
        
        
            Removes white noise from an image.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Derivative
            
        
        
            Computes the derivative of the source layer along the x- and y-axis.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Dilate Erode
            
        
        
            Dilates or erodes a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Distort
            
        
        
            Distorts an input layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Dot Product
            
        
        
            Performs dot product between two layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Edge Detect
            
        
        
            Detects edges in the input image.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Edge Detect by Contour
            
        
        
            Detects varying-width silhouette lines.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Edge Detect by Depth
            
        
        
            Detects varying-width self-occluding silhouettes.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Edge Detect by Normal
            
        
        
            Detects varying-width crease-lines.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Eikonal
            
        
        
            Computes distances by solving the Eikonal equation.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Equalize
            
        
        
            Equalizes colors by stretching or shifting their range.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Error
            
        
        
            Generates a message, warning, or error.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Extrapolate Boundaries
            
        
        
            Fills empty areas of an image using colors at the edges of non-empty areas.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Feather
            
        
        
            Smooths out sharp changes in contrast.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Fetch
            
        
        
            Brings a COP node’s outputs into the current network.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                File
            
        
        
            Loads an image or video from disk.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Fill
            
        
        
            Fills a layer with a constant value.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Fill Connected
            
        
        
            Flood fills the connected regions of a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Flip
            
        
        
            Flips a layer horizontally, vertically, or diagonally.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Flow Block Begin
            
        
        
            Start of a Flow simulation block.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Flow Block End
            
        
        
            End of a Flow simulation block.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Flow Project Non-Divergent Multigrid
            
        
        
            Removes divergent components from a 2-dimensional vector field.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Font
            
        
        
            Rasterizes text onto a layer from Type 1, TrueType, and OpenType fonts.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Fractal Noise
            
        
        
            Generates fractal noise.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Fractal Noise 3D
            
        
        
            Generates fractal noise from 3D locations.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Function
            
        
        
            Applies a mathematical function to a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Gamma
            
        
        
            Applies gamma correction to a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Geometry to Layer
            
        
        
            Converts a volume into a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Glow
            
        
        
            Adds glow to an image based on its luminance.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Grunge Aurora
            
        
        
            Generates a pattern resembling an aurora display.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Grunge Birch Bark
            
        
        
            Generates a pattern resembling the bark of a birch tree.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Grunge Layered Noise
            
        
        
            Generates a higher-level noise pattern by layering simple noises.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Grunge Pine Bark
            
        
        
            Generates a pattern resembling the bark of a pine tree.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Grunge Rust
            
        
        
            Generates a pattern resembling rust on a surface.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                HSV Adjust
            
        
        
            Converts between RGB and HSV color spaces, or modifies HSV.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Heat Distort
            
        
        
            Distorts the input layer to simulate heat around fire and other mirage effects.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Heat Distort by Layer
            
        
        
            Distorts the input layer using another layer to simulate heat around fire and other mirage effects.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Height to Ambient Occlusion
            
        
        
            Imagines a sphere for each pixel and determines how occluded that sphere is based on its surroundings.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Height to Normal
            
        
        
            Converts a height layer to a normal layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Height to Shadow
            
        
        
            Creates shadows using a virtual light source.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                HeightField Visualize
            
        
        
            Visualizes layers as colored heightfields.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Hex Tile
            
        
        
            Randomly tiles texture.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Histogram
            
        
        
            Builds a histogram from a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Hyperbolic Tile
            
        
        
            Generates hyperbolic polygon tiles for texture patterns.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                ID to Mask
            
        
        
            Creates a mask from an ID layer based on filtering parameters.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                ID to Mono
            
        
        
            Converts an ID layer into a mono layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                ID to RGB
            
        
        
            Converts an ID layer into an RGB layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                ID to SDF
            
        
        
            Computes a Signed Distance Field from changes in ID values.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Illegal Pixel
            
        
        
            Detects and then fixes or highlights illegal pixels in images.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Input
            
        
        
            Fetches the input to a subnetwork.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Integrate Volume
            
        
        
            Integrates a VDB along camera rays.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Invert
            
        
        
            Inverts a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Invoke Block
            
        
        
            Runs a block using inputs plugged into this node.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Invoke Geometry
            
        
        
            Runs a program saved into geometry using inputs plugged into this node.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Julia Fractal
            
        
        
            Computes the Julia set to create a fractal.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Kuwahara Filter
            
        
        
            Applies the Kuwahara filter, which creates painterly effects.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Lattice Deform
            
        
        
            Applies grid-based deformation to a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer
            
        
        
            Generates a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer Attribute Create
            
        
        
            Adds or edits user-defined metadata on a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer Attribute Delete
            
        
        
            Removes user-defined metadata from a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer Properties
            
        
        
            Edits basic layer metadata.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer from Curves
            
        
        
            Render Curves into a Layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer from VDB
            
        
        
            Sets a layer’s values from a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer to Geometry
            
        
        
            Converts a layer into a 2D volume.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer to Points
            
        
        
            Creates points based on a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Layer to VDB Leaf Points
            
        
        
            Creates a point for each leaf of a VDB that would be in an envelope.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Lens Distort
            
        
        
            Adds radial and tangential distortion to a layer based on OpenCV coefficients.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Light
            
        
        
            Lights a layer given a light direction and normals.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Live Video
            
        
        
            Captures images from a live video source.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Mask from Curves
            
        
        
            Creates a mask from 2D curves.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Match Camera
            
        
        
            Transforms a layer to match a reference camera.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Match UDIM
            
        
        
            Reframes pixels of a layer to match a particular UDIM tile.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Median
            
        
        
            Applies a median filter to an image.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Mirror
            
        
        
            Mirrors an image based on an arbitrary number of planes.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Mono
            
        
        
            Converts a layer to mono.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Mono to ID
            
        
        
            Converts a mono layer into an ID layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Mono to RGB
            
        
        
            Converts a mono layer into an RGB layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Mono to RGBA
            
        
        
            Converts a mono layer into an RGBA layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Mono to SDF
            
        
        
            Computes a signed distance field from an iso-level of a mono layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Null
            
        
        
            Passes inputs to the outputs.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                OCIO Transform
            
        
        
            Converts color spaces using OCIO transforms.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                ONNX Inference
            
        
        
            Applies inference from an ONNX Machine Learning model.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                OpenCL
            
        
        
            Executes an OpenCL kernel on layers, attributes, volumes, and VDBs.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Output
            
        
        
            Collects the outputs of a subnetwork.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Phasor Noise
            
        
        
            Generates phasor noise, which resembles a wave pattern.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pixelate
            
        
        
            Increases the size of pixels to pixelate an input layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Polar to UV
            
        
        
            Converts polar coordinate pixels to Cartesian pixels.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Position Map
            
        
        
            Generates a position map.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Position Sample
            
        
        
            Samples an input texture by position.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Prefix Sum
            
        
        
            Computes the prefix sum of a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Premultiply
            
        
        
            Premultiplies or un-premultiplies an RGBA layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Preview Material
            
        
        
            Applies the preview material to geometry.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Project on Layer
            
        
        
            Projects a layer onto a target layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Activate
            
        
        
            Changes the activation of VDBs in a Pyro simulation.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Advect
            
        
        
            Advects VDBs by Velocity.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Advect by Map
            
        
        
            Advects a VDB by a flow map.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Axis Force
            
        
        
            Applies a force around an axis to a velocity VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Block Begin
            
        
        
            Start of a Pyro simulation block.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Block End
            
        
        
            End of a Pyro simulation block.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Build Advection Map
            
        
        
            Constructs a flow map from a velocity VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Buoyancy
            
        
        
            Applies a Buoyancy force.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Configure
            
        
        
            Configures a Pyro simulation.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Dissipate
            
        
        
            Dissipates a VDB’s values over time.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Disturbance
            
        
        
            Applies disturbance to a velocity VDB to break up still air.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Light Ambient
            
        
        
            Builds a light field of ambient illumination of a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Light Scatter
            
        
        
            Builds a light field of internal glow of a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Light from Points
            
        
        
            Builds a light field of points lighting a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Packed MipMap
            
        
        
            Builds an in-place MipMap of a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Project Non-Divergent Electro Static
            
        
        
            Removes divergence from a velocity VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Source from Layer
            
        
        
            Sources from a layer’s envelope into a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Source from Points
            
        
        
            Sources points into a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Turbulence
            
        
        
            Apply turbulence to a velocity VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Pyro Uniform Force
            
        
        
            Applies a uniform force.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Python Snippet
            
        
        
            Runs a snippet of Python on layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Quantize
            
        
        
            Quantizes input data into discrete steps.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                RGB to RGBA
            
        
        
            Converts RGB layers to RGBA.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                RGB to UV
            
        
        
            Splits an RGB layer into UV and mono layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                RGBA to RGB
            
        
        
            Converts RGBA layers to RGB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                RGBA to UV
            
        
        
            Splits an RGBA layer into two UV layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                ROP Image
            
        
        
            Writes the output of a COP network to disk.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Ramp
            
        
        
            Generates linear and radial ramps.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Random Mono
            
        
        
            Creates a mono layer with random values.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Random RGB
            
        
        
            Creates an RGB layer with random colors.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Rasterize Curves
            
        
        
            Rasterizes curves onto a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Rasterize Geometry
            
        
        
            Rasterizes geometry onto a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Rasterize Layer
            
        
        
            Rasterizes a layer onto another layer’s camera.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Rasterize Setup
            
        
        
            Prepares geometry for the Rasterize Geometry COP.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Rasterize Volume
            
        
        
            Renders a volume viewed through a camera.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Ray Trace
            
        
        
            Performs ray tracing on an input mesh based on an origins and directions map.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Reaction-Diffusion Block Begin
            
        
        
            Start of a Reaction-Diffusion simulation block.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Reaction-Diffusion Block End
            
        
        
            Creates unique patterns by solving the reaction and diffusion of multiple chemicals as described by its inputs and parameters.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Remap
            
        
        
            Remaps a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Resample
            
        
        
            Performs image scaling by changing the width, height, and pixel sizes.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                SDF Adjust
            
        
        
            Modifies the values for a Mono SDF layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                SDF Blend
            
        
        
            Combines two Mono SDF layers.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                SDF Shape
            
        
        
            Builds a 2D signed distance field of a selected shape.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                SDF to Mono
            
        
        
            Converts an SDF field to a Mono image layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                SDF to RGB
            
        
        
            Converts an SDF field to an RGB color layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                SOP Import
            
        
        
            Imports SOP geometry into Copernicus.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                SOP Invoke
            
        
        
            Invokes a compiled SOP block on the inputs.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                SOP Invoke Graph
            
        
        
            Invokes a geometry SOP graph on the inputs.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Scatter Shapes
            
        
        
            Scatters input stamps across the image using randomization controls.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Scatter on Curves
            
        
        
            Scatters input stamps along an input curve using randomization controls.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Segment by Connectivity
            
        
        
            Segment a layer into connected components.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Segment by Value
            
        
        
            Segment a mono layer into bands of similar value.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Sequence Blend
            
        
        
            Blends multiple image inputs by a blend factor.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Sharpen
            
        
        
            Sharpens an input layer to increase the definition of its edges.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Slap Comp Import
            
        
        
            Import live layers from the Solaris Viewport.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Slope Direction
            
        
        
            Converts a height layer into a direction layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Smooth Fill
            
        
        
            Smoothly fills a region of a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Solve Poisson Multigrid
            
        
        
            Solves Poisson’s equation in a rectangular region using geometric multigrid.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Space Transform
            
        
        
            Transforms positions and UV values between spaces.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Stamp Points
            
        
        
            Stamps layers from point positions.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Stash
            
        
        
            Stashes the input of the node on command and uses it as the node’s output.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Statistics
            
        
        
            Outputs the average, minimum and maximum values of the input layer
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Statistics by ID
            
        
        
            Compute statistics for each ID island.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Streak Blur
            
        
        
            Streaks an image, adding a motion blur effect.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Subnetwork
            
        
        
            Used to organize a collection of COPs into one node.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Surface Dither
            
        
        
            Applies a halftone dithering pattern relative to UVs.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Swirl
            
        
        
            Twists an image layer into a spiral shape.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Switch
            
        
        
            Selects an input layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Switch If Wired
            
        
        
            Selects an input based on what is connected.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Switch by Type
            
        
        
            Selects an output layer by the type of the inputs.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Tile Pattern
            
        
        
            Generates rectangular tiles for texture patterns.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Tone Map
            
        
        
            Applies a filmic tone mapping curve to compress a high dynamic range input into a displayable range.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Transform 2D
            
        
        
            Transforms a layer in 2D.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Transform 3D
            
        
        
            Transforms a layer in 3D.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Triplanar
            
        
        
            Generates a texture by projecting X, Y, and Z textures onto the position layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Triplanar Hex Tile
            
        
        
            Seamless texturing and normal mapping of triplanar projections without visible repetitions.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Triplanar UV
            
        
        
            Generates UVs in three orthogonal projections.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Two Way Switch If Wired
            
        
        
            Selects between two inputs based on if you wire in another input.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                UV Map
            
        
        
            Generates a UV Map.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                UV Map by ID
            
        
        
            Creates a UV Map for each connected ID island.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                UV Sample
            
        
        
            Samples an input layer using a UV layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                UV Transform
            
        
        
            Transforms the values of a UV layer in 2d space.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                UV to Polar
            
        
        
            Converts Cartesian coordinate pixels to polar coordinate pixels.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                UV to RGB
            
        
        
            Joins a UV and mono layer into an RGB layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                UV to RGBA
            
        
        
            Joins two UV layers into an RGBA layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB Activate from Points
            
        
        
            Activates leaves on a VDB according to a point cloud.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB Leaf Points
            
        
        
            Creates a point for each active leaf in a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB Position Map
            
        
        
            Stores in each voxel that voxel’s position.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB Reshape
            
        
        
            Rebuilds a VDB to match another VDB’s topology.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB Visualize
            
        
        
            Creates multi-volume visualization.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB Visualize Slice
            
        
        
            Extracts a slice from a VDB as Geometry for visualization.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB Visualize Tree
            
        
        
            Builds a geometry visualizing the topology of a VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB Visualize Velocity
            
        
        
            Traces streamers through a velocity VDB.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                VDB from Layer
            
        
        
            Sets VDB values from the closest values in a layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Vector Transform
            
        
        
            Transforms values of an RGB layer in 3d space.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Vector Transform 2D
            
        
        
            Transforms the values of a UV layer in 2D space.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Vignette
            
        
        
            Darkens the corners of an input layer.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Wipe
            
        
        
            Performs a wipe transition between two images.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Worley Noise
            
        
        
            Generates Worley noise.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Worley Noise 3D
            
        
        
            Generates Worley noise from 3D locations.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Wrangle
            
        
        
            Runs a VEX snippet to modify layer values.
        
        
     
    
        
    
    
    
    - 
        
            
        
        
            
                Z Composite
            
        
        
            Composites two layers by depth.