base-node (.bn) v0.13.1

Nodes of a compositor tree

The 181 nodes a compositor graph can write in Blender 5.3.0, by the name the text calls them. The signature is a new node's: a setting may show or hide inputs (Math(operation: SINE) has one). Keys repeat as Blender's identifiers (Value_001).

ActiveCamera Retrieve the scene's active camera

Active Camera · GeometryNodeInputActiveCamera · link

ActiveCamera() -> (active_camera: Object)
AlignRotationToVector Orient a rotation along the given direction

Align Rotation to Vector · FunctionNodeAlignRotationToVector · link

AlignRotationToVector(
  rotation: Rotation = (0.0, 0.0, 0.0),
  factor: Float = 1.0,
  vector: Vector = (0.0, 0.0, 1.0),
  axis: Z,
  pivot_axis: AUTO
) -> (rotation: Rotation)
SettingValuesDefault
axisX, Y, ZZAxis to align to the vector
pivot_axisAUTO, X, Y, ZAUTOAxis to rotate around
AlphaConvert Convert to and from premultiplied (associated) alpha

Alpha Convert · CompositorNodePremulKey · link

AlphaConvert(image: Color = (1.0, 1.0, 1.0, 1.0), type: Menu = "To Premultiplied") -> (image: Color)
AlphaOver Overlay a foreground image onto a background image

Alpha Over · CompositorNodeAlphaOver · link

AlphaOver(
  background: Color = (1.0, 1.0, 1.0, 1.0),
  foreground: Color = (1.0, 1.0, 1.0, 1.0),
  factor: Float = 1.0,
  type: Menu = "Over",
  straight_alpha: Bool = false
) -> (image: Color)
AntiAliasing Smooth away jagged edges

Anti-Aliasing · CompositorNodeAntiAliasing · link

AntiAliasing(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  threshold: Float = 0.2,
  contrast_limit: Float = 2.0,
  corner_rounding: Float = 0.25
) -> (image: Color)
AxesToRotation Create a rotation from a primary and (ideally orthogonal) secondary axis

Axes to Rotation · FunctionNodeAxesToRotation · link

AxesToRotation(
  primary_axis: Vector = (0.0, 0.0, 1.0),
  secondary_axis: Vector = (1.0, 0.0, 0.0),
  primary_axis: Z,
  secondary_axis: X
) -> (rotation: Rotation)
SettingValuesDefault
primary_axisX, Y, ZZAxis that is aligned exactly to the provided primary direction
secondary_axisX, Y, ZXAxis that is aligned as well as possible given the alignment of the primary axis
AxisAngleToRotation Build a rotation from an axis and a rotation around that axis

Axis Angle to Rotation · FunctionNodeAxisAngleToRotation · link

AxisAngleToRotation(axis: Vector = (0.0, 0.0, 1.0), angle: Float = 0.0) -> (rotation: Rotation)
BilateralBlur Adaptively blur image, while retaining sharp edges

Bilateral Blur · CompositorNodeBilateralblur · link

BilateralBlur(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  determinator: Color = (1.0, 1.0, 1.0, 1.0),
  size: Int = 0,
  threshold: Float = 0.1
) -> (image: Color)
BitMath Perform bitwise operations on 32-bit integers

Bit Math · FunctionNodeBitMath · link

BitMath(a: Int = 0, b: Int = 0, operation: AND) -> (value: Int)
SettingValuesDefault
operationAND, OR, XOR, NOT, SHIFT, ROTATEAND
Blackbody Convert a blackbody temperature to an RGB value

Blackbody · ShaderNodeBlackbody · link

Blackbody(temperature: Float = 6500.0) -> (color: Color)
BlankImage Returns an image with the given size and constant color

Blank Image · CompositorNodeBlankImage · link

BlankImage(color: Color = (0.0, 0.0, 0.0, 1.0), size: Int_Vector = (1920, 1080)) -> (image: Color)
Blur Blur an image, using several blur modes

Blur · CompositorNodeBlur · link

Blur(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  size: Vector = (0.0, 0.0),
  type: Menu = "Gaussian",
  extend_bounds: Bool = false,
  separable: Bool = true
) -> (image: Color)
BokehBlur Generate a bokeh type blur similar to Defocus. Unlike defocus an in-focus region is defined in the compositor

Bokeh Blur · CompositorNodeBokehBlur · link

BokehBlur(
  image: Color = (0.8, 0.8, 0.8, 1.0),
  bokeh: Color = (1.0, 1.0, 1.0, 1.0),
  size: Float = 0.0,
  mask: Float = 1.0,
  extend_bounds: Bool = false
) -> (image: Color)
BokehImage Generate image with bokeh shape for use with the Bokeh Blur filter node

Bokeh Image · CompositorNodeBokehImage · link

BokehImage(
  flaps: Int = 5,
  angle: Float = 0.0,
  roundness: Float = 0.0,
  catadioptric_size: Float = 0.0,
  color_shift: Float = 0.0
) -> (image: Color)
BoneInfo Retrieve information of armature bones

Bone Info · GeometryNodeBoneInfo · link

BoneInfo(armature: Object, bone_name: String = "", transform_space: ORIGINAL) -> (pose: Matrix, local_pose: Matrix, transform_pose: Matrix, rest_pose: Matrix, rest_length: Float, exists: Bool, envelope_distance: Float, radius_head: Float, radius_tail: Float)
SettingValuesDefault
transform_spaceORIGINAL, RELATIVEORIGINALThe transformation of the vector and geometry outputs
Boolean Provide a True/False value that can be connected to other nodes in the tree

Boolean · FunctionNodeInputBool · link

Boolean(boolean: false) -> (boolean: Bool)
SettingValuesDefault
booleanbooleanfalseInput value used for unconnected socket
BooleanMath Perform a logical operation on the given boolean inputs

Boolean Math · FunctionNodeBooleanMath · link

BooleanMath(Boolean: Bool = false, Boolean_001: Bool = false, operation: AND) -> (boolean: Bool)
SettingValuesDefault
operationAND, OR, NOT, NAND, NOR, XNOR, XOR, IMPLY, NIMPLYAND
BoxMask Create rectangular mask suitable for use as a simple matte

Box Mask · CompositorNodeBoxMask · link

BoxMask(
  operation: Menu = "Add",
  mask: Float = 0.0,
  value: Float = 1.0,
  position: Vector = (0.5, 0.5),
  size: Vector = (0.2, 0.1),
  rotation: Float = 0.0
) -> (mask: Float)
BrickTexture Generate a procedural texture producing bricks

Brick Texture · ShaderNodeTexBrick · link

BrickTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  color1: Color = (0.8, 0.8, 0.8, 1.0),
  color2: Color = (0.2, 0.2, 0.2, 1.0),
  mortar: Color = (0.0, 0.0, 0.0, 1.0),
  scale: Float = 5.0,
  mortar_size: Float = 0.02,
  mortar_smooth: Float = 0.1,
  bias: Float = 0.0,
  brick_width: Float = 0.5,
  row_height: Float = 0.25,
  offset_frequency: 2,
  squash_frequency: 2,
  offset: 0.5,
  squash: 1.0
) -> (color: Color, factor: Float)
SettingValuesDefault
offset_frequencyint2How often rows are offset. A value of 2 gives an even/uneven pattern of rows.
squash_frequencyint2How often rows consist of "squished" bricks
offsetfloat0.5Determines the brick offset of the various rows
squashfloat1.0Factor to adjust the brick's width for particular rows determined by the Offset Frequency
BrightnessContrast Adjust brightness and contrast

Brightness/Contrast · CompositorNodeBrightContrast · link

BrightnessContrast(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  brightness: Float = 0.0,
  contrast: Float = 0.0
) -> (image: Color)
CameraInfo Retrieve information from a camera object

Camera Info · GeometryNodeCameraInfo · link

CameraInfo(camera: Object) -> (projection_matrix: Matrix, focal_length: Float, sensor: Vector, shift: Vector, clip_start: Float, clip_end: Float, focus_distance: Float, is_orthographic: Bool, orthographic_scale: Float)
ChannelKey Create matte based on differences in color channels

Channel Key · CompositorNodeChannelMatte · link

ChannelKey(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  minimum: Float = 0.0,
  maximum: Float = 1.0,
  color_space: Menu = RGB,
  rgb_key_channel: Menu = G,
  hsv_key_channel: Menu = H,
  yuv_key_channel: Menu = V,
  ycbcr_key_channel: Menu = "Cr",
  limit_method: Menu = "Max",
  rgb_limit_channel: Menu = R,
  hsv_limit_channel: Menu = S,
  yuv_limit_channel: Menu = U,
  ycbcr_limit_channel: Menu = "Cb"
) -> (image: Color, matte: Float)
CheckerTexture Generate a checkerboard texture

Checker Texture · ShaderNodeTexChecker · link

CheckerTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  color1: Color = (0.8, 0.8, 0.8, 1.0),
  color2: Color = (0.2, 0.2, 0.2, 1.0),
  scale: Float = 5.0
) -> (color: Color, factor: Float)
ChromaKey Create matte based on chroma values

Chroma Key · CompositorNodeChromaMatte · link

ChromaKey(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  key_color: Color = (1.0, 1.0, 1.0, 1.0),
  minimum: Float = 0.174533,
  maximum: Float = 0.523599,
  falloff: Float = 1.0
) -> (image: Color, matte: Float)
Clamp Clamp a value between a minimum and a maximum

Clamp · ShaderNodeClamp · link

Clamp(
  value: Float = 1.0,
  min: Float = 0.0,
  max: Float = 1.0,
  clamp_type: MINMAX
) -> (result: Float)
SettingValuesDefault
clamp_typeMINMAX, RANGEMINMAX
Color A color picker

Color · CompositorNodeRGB · link

Color() -> (color: Color)
ColorBalance Adjust color and values

Color Balance · CompositorNodeColorBalance · link

ColorBalance(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  factor: Float = 1.0,
  type: Menu = "Lift/Gamma/Gain",
  Base Lift: Float = 0.0,
  Color Lift: Color = (1.0, 1.0, 1.0, 1.0),
  Base Gamma: Float = 1.0,
  Color Gamma: Color = (1.0, 1.0, 1.0, 1.0),
  Base Gain: Float = 1.0,
  Color Gain: Color = (1.0, 1.0, 1.0, 1.0),
  Base Offset: Float = 0.0,
  Color Offset: Color = (0.0, 0.0, 0.0, 1.0),
  Base Power: Float = 1.0,
  Color Power: Color = (1.0, 1.0, 1.0, 1.0),
  Base Slope: Float = 1.0,
  Color Slope: Color = (1.0, 1.0, 1.0, 1.0),
  Input Temperature: Float = 6500.0,
  Input Tint: Float = 10.0,
  Output Temperature: Float = 6500.0,
  Output Tint: Float = 10.0
) -> (image: Color)
ColorCorrection Adjust the color of an image, separately in several tonal ranges (highlights, midtones and shadows)

Color Correction · CompositorNodeColorCorrection · link

ColorCorrection(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  mask: Float = 1.0,
  Master Saturation: Float = 1.0,
  Master Contrast: Float = 1.0,
  Master Gamma: Float = 1.0,
  Master Gain: Float = 1.0,
  Master Offset: Float = 0.0,
  Highlights Saturation: Float = 1.0,
  Highlights Contrast: Float = 1.0,
  Highlights Gamma: Float = 1.0,
  Highlights Gain: Float = 1.0,
  Highlights Offset: Float = 0.0,
  Midtones Saturation: Float = 1.0,
  Midtones Contrast: Float = 1.0,
  Midtones Gamma: Float = 1.0,
  Midtones Gain: Float = 1.0,
  Midtones Offset: Float = 0.0,
  Shadows Saturation: Float = 1.0,
  Shadows Contrast: Float = 1.0,
  Shadows Gamma: Float = 1.0,
  Shadows Gain: Float = 1.0,
  Shadows Offset: Float = 0.0,
  midtones_start: Float = 0.2,
  midtones_end: Float = 0.7,
  red: Bool = true,
  green: Bool = true,
  blue: Bool = true
) -> (image: Color)
ColorKey Create matte using a given color, for green or blue screen footage

Color Key · CompositorNodeColorMatte · link

ColorKey(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  key_color: Color = (1.0, 1.0, 1.0, 1.0),
  hue: Float = 0.01,
  saturation: Float = 0.1,
  value: Float = 0.1
) -> (image: Color, matte: Float)
ColorRamp Map values to colors with the use of a gradient

Color Ramp · ShaderNodeValToRGB · link

ColorRamp(factor: Float = 0.5) -> (color: Color, alpha: Float)

Data: color_ramp (ramp)

ColorSpill Remove colors from a blue or green screen, by reducing one RGB channel compared to the others

Color Spill · CompositorNodeColorSpill · link

ColorSpill(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  factor: Float = 1.0,
  spill_channel: Menu = G,
  limit_method: Menu = "Single",
  limit_channel: Menu = R,
  limit_strength: Float = 1.0,
  use_spill_strength: Bool = false,
  strength: Color = (0.0, 1.0, 0.0, 1.0)
) -> (image: Color)
CombineBundle Combine multiple socket values into one.

Combine Bundle · NodeCombineBundle · link

CombineBundle(define_signature: false) -> (bundle: Bundle)
SettingValuesDefault
define_signaturebooleanfalseThis node defines a bundle signature that should be used by other nodes
CombineColor Combine an image from its composite color channels

Combine Color · CompositorNodeCombineColor · link

CombineColor(
  red: Float = 0.0,
  green: Float = 0.0,
  blue: Float = 0.0,
  alpha: Float = 1.0,
  mode: RGB,
  ycc_mode: ITUBT709
) -> (image: Color)
SettingValuesDefault
modeRGB, HSV, HSL, YCC, YUVRGBMode of color processing
ycc_modeITUBT601, ITUBT709, JFIFITUBT709Color space used for YCbCrA processing
CombineMatrix Construct a 4x4 matrix from its individual values

Combine Matrix · FunctionNodeCombineMatrix · link

CombineMatrix(
  column_1_row_1: Float = 1.0,
  column_1_row_2: Float = 0.0,
  column_1_row_3: Float = 0.0,
  column_1_row_4: Float = 0.0,
  column_2_row_1: Float = 0.0,
  column_2_row_2: Float = 1.0,
  column_2_row_3: Float = 0.0,
  column_2_row_4: Float = 0.0,
  column_3_row_1: Float = 0.0,
  column_3_row_2: Float = 0.0,
  column_3_row_3: Float = 1.0,
  column_3_row_4: Float = 0.0,
  column_4_row_1: Float = 0.0,
  column_4_row_2: Float = 0.0,
  column_4_row_3: Float = 0.0,
  column_4_row_4: Float = 1.0
) -> (matrix: Matrix)
CombineTransform Combine a translation vector, a rotation, and a scale vector into a transformation matrix

Combine Transform · FunctionNodeCombineTransform · link

CombineTransform(
  translation: Vector = (0.0, 0.0, 0.0),
  rotation: Rotation = (0.0, 0.0, 0.0),
  scale: Vector = (1.0, 1.0, 1.0)
) -> (transform: Matrix)
CombineXYZ Create a vector from X, Y, and Z components

Combine XYZ · ShaderNodeCombineXYZ · link

CombineXYZ(x: Float = 0.0, y: Float = 0.0, z: Float = 0.0) -> (vector: Vector)
Comment Add explanations to the node group

Comment · NodeComment · link

Comment(text: "## Comment")
SettingValuesDefault
textstring"## Comment"Text to show in the node
Compare Perform a comparison operation on the two given inputs

Compare · FunctionNodeCompare · link

Compare(
  a: Float = 0.0,
  b: Float = 0.0,
  operation: GREATER_THAN,
  data_type: FLOAT,
  mode: ELEMENT
) -> (result: Bool)
SettingValuesDefault
operationLESS_THAN, LESS_EQUAL, GREATER_THAN, GREATER_EQUAL, EQUAL, NOT_EQUAL, BRIGHTER, DARKERGREATER_THAN
data_typeFLOAT, INT, BOOLEAN, VECTOR, RGBA, ROTATION, MATRIX, STRING, MENU, SHADER, OBJECT, IMAGE, GEOMETRY, COLLECTION, TEXTURE, MATERIAL, BUNDLE, CLOSURE, FONT, SCENE, TEXT, MASK, SOUND, INT_VECTORFLOAT
modeELEMENT, LENGTH, AVERAGE, DOT_PRODUCT, DIRECTIONELEMENT
CompositorNodeSwitch Switch between two images using a checkbox

Switch · CompositorNodeSwitch · link

CompositorNodeSwitch(
  switch: Bool = false,
  off: Color = (0.8, 0.8, 0.8, 1.0),
  on: Color = (0.8, 0.8, 0.8, 1.0)
) -> (image: Color)
ConvertColorspace Convert between color spaces

Convert Colorspace · CompositorNodeConvertColorSpace · link

ConvertColorspace(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  from_color_space: "scene_linear",
  from_interop_id: "lin_rec709_scene",
  to_color_space: "scene_linear",
  to_interop_id: "lin_rec709_scene"
) -> (image: Color)
SettingValuesDefault
from_color_spaceACES 1.3 sRGB, ACES 2.0 sRGB, ACES2065-1, ACEScc, ACEScct, ACEScg, ADX10, ADX16, ARRI LogC3 (EI800), ARRI LogC4, AgX Base sRGB, AgX Log, Apple Log, Apple Log 2, BMDFilm WideGamut Gen5, CanonLog2 CinemaGamut D55, CanonLog3 CinemaGamut D55, D-Log D-Gamut, DaVinci Intermediate WideGamut, Display P3, Filmic Log, Filmic sRGB, Gamma 1.8 Encoded Rec.709, Gamma 2.2 Encoded AP1, Gamma 2.2 Encoded AdobeRGB, Gamma 2.2 Encoded Rec.709, Gamma 2.4 Encoded Rec.709, Khronos PBR Neutral sRGB, Linear ARRI Wide Gamut 3, Linear ARRI Wide Gamut 4, Linear Adobe RGB, Linear Apple Wide Gamut, Linear BMD WideGamut Gen5, Linear CIE-XYZ D65, Linear CIE-XYZ E, Linear CinemaGamut D55, Linear D-Gamut, Linear DCI-P3 D65, Linear DaVinci WideGamut, Linear FilmLight E-Gamut, Linear REDWideGamutRGB, Linear Rec.2020, Linear Rec.709, Linear S-Gamut3, Linear S-Gamut3.Cine, Linear V-Gamut, Linear Venice S-Gamut3, Linear Venice S-Gamut3.Cine, Log3G10 REDWideGamutRGB, Non-Color, Rec.1886, Rec.2020, Rec.2100-HLG, Rec.2100-PQ, Rec.709-A, S-Log3 S-Gamut3, S-Log3 S-Gamut3.Cine, S-Log3 Venice S-Gamut3, S-Log3 Venice S-Gamut3.Cine, V-Log V-Gamut, sRGB, sRGB Encoded AP1, sRGB Encoded P3-D65, scene_linear"scene_linear"Color space of the input image
from_interop_idNONE, blender:agxlog_rec2020_scene, blender:filmiclog_rec709_scene, blender:g1961_rec709_display, blender:g24_rec2020_display, blender:lin_ciexyze_scene, blender:lin_egamut_scene, data, g18_rec709_scene, g22_adobergb_scene, g22_ap1_scene, g22_rec709_scene, g24_rec709_display, g24_rec709_scene, hlg_rec2020_display, lin_adobergb_scene, lin_ap0_scene, lin_ap1_scene, lin_ciexyzd65_scene, lin_p3d65_scene, lin_rec2020_scene, lin_rec709_scene, ocio:acescc_ap1_scene, ocio:acescct_ap1_scene, ocio:adx10_apd_scene, ocio:adx16_apd_scene, ocio:applelog_applewg_scene, ocio:applelog_rec2020_scene, ocio:arrilogc3_awg3_scene, ocio:arrilogc4_awg4_scene, ocio:bmdfilm5_wg5_scene, ocio:canonlog2_cgamutd55_scene, ocio:canonlog3_cgamutd55_scene, ocio:davinci_dwg_scene, ocio:djilog_dgamut_scene, ocio:lin_awg3_scene, ocio:lin_awg4_scene, ocio:lin_bmdwg5_scene, ocio:lin_cgamutd55_scene, ocio:lin_dgamut_scene, ocio:lin_dwg_scene, ocio:lin_rwg_scene, ocio:lin_sgamut3_scene, ocio:lin_sgamut3cine_scene, ocio:lin_sgamut3cinevenice_scene, ocio:lin_sgamut3venice_scene, ocio:lin_vgamut_scene, ocio:linear_applewg_scene, ocio:redlog3g10_rwg_scene, ocio:slog3_sgamut3_scene, ocio:slog3_sgamut3cine_scene, ocio:slog3_sgamut3cinevenice_scene, ocio:slog3_sgamut3venice_scene, ocio:vlog_vgamut_scene, pq_rec2020_display, srgb_ap1_scene, srgb_p3d65_display, srgb_p3d65_scene, srgb_rec709_display, g22_rec709_display, lin_p3d65_display, lin_rec2020_display, lin_rec709_display, srgb_rec709_scene"lin_rec709_scene"Interop ID of the input color space
to_color_spaceACES 1.3 sRGB, ACES 2.0 sRGB, ACES2065-1, ACEScc, ACEScct, ACEScg, ADX10, ADX16, ARRI LogC3 (EI800), ARRI LogC4, AgX Base sRGB, AgX Log, Apple Log, Apple Log 2, BMDFilm WideGamut Gen5, CanonLog2 CinemaGamut D55, CanonLog3 CinemaGamut D55, D-Log D-Gamut, DaVinci Intermediate WideGamut, Display P3, Filmic Log, Filmic sRGB, Gamma 1.8 Encoded Rec.709, Gamma 2.2 Encoded AP1, Gamma 2.2 Encoded AdobeRGB, Gamma 2.2 Encoded Rec.709, Gamma 2.4 Encoded Rec.709, Khronos PBR Neutral sRGB, Linear ARRI Wide Gamut 3, Linear ARRI Wide Gamut 4, Linear Adobe RGB, Linear Apple Wide Gamut, Linear BMD WideGamut Gen5, Linear CIE-XYZ D65, Linear CIE-XYZ E, Linear CinemaGamut D55, Linear D-Gamut, Linear DCI-P3 D65, Linear DaVinci WideGamut, Linear FilmLight E-Gamut, Linear REDWideGamutRGB, Linear Rec.2020, Linear Rec.709, Linear S-Gamut3, Linear S-Gamut3.Cine, Linear V-Gamut, Linear Venice S-Gamut3, Linear Venice S-Gamut3.Cine, Log3G10 REDWideGamutRGB, Non-Color, Rec.1886, Rec.2020, Rec.2100-HLG, Rec.2100-PQ, Rec.709-A, S-Log3 S-Gamut3, S-Log3 S-Gamut3.Cine, S-Log3 Venice S-Gamut3, S-Log3 Venice S-Gamut3.Cine, V-Log V-Gamut, sRGB, sRGB Encoded AP1, sRGB Encoded P3-D65, scene_linear"scene_linear"Color space of the output image
to_interop_idNONE, blender:agxlog_rec2020_scene, blender:filmiclog_rec709_scene, blender:g1961_rec709_display, blender:g24_rec2020_display, blender:lin_ciexyze_scene, blender:lin_egamut_scene, data, g18_rec709_scene, g22_adobergb_scene, g22_ap1_scene, g22_rec709_scene, g24_rec709_display, g24_rec709_scene, hlg_rec2020_display, lin_adobergb_scene, lin_ap0_scene, lin_ap1_scene, lin_ciexyzd65_scene, lin_p3d65_scene, lin_rec2020_scene, lin_rec709_scene, ocio:acescc_ap1_scene, ocio:acescct_ap1_scene, ocio:adx10_apd_scene, ocio:adx16_apd_scene, ocio:applelog_applewg_scene, ocio:applelog_rec2020_scene, ocio:arrilogc3_awg3_scene, ocio:arrilogc4_awg4_scene, ocio:bmdfilm5_wg5_scene, ocio:canonlog2_cgamutd55_scene, ocio:canonlog3_cgamutd55_scene, ocio:davinci_dwg_scene, ocio:djilog_dgamut_scene, ocio:lin_awg3_scene, ocio:lin_awg4_scene, ocio:lin_bmdwg5_scene, ocio:lin_cgamutd55_scene, ocio:lin_dgamut_scene, ocio:lin_dwg_scene, ocio:lin_rwg_scene, ocio:lin_sgamut3_scene, ocio:lin_sgamut3cine_scene, ocio:lin_sgamut3cinevenice_scene, ocio:lin_sgamut3venice_scene, ocio:lin_vgamut_scene, ocio:linear_applewg_scene, ocio:redlog3g10_rwg_scene, ocio:slog3_sgamut3_scene, ocio:slog3_sgamut3cine_scene, ocio:slog3_sgamut3cinevenice_scene, ocio:slog3_sgamut3venice_scene, ocio:vlog_vgamut_scene, pq_rec2020_display, srgb_ap1_scene, srgb_p3d65_display, srgb_p3d65_scene, srgb_rec709_display, g22_rec709_display, lin_p3d65_display, lin_rec2020_display, lin_rec709_display, srgb_rec709_scene"lin_rec709_scene"Interop ID of the output color space
ConvertToDisplay Convert from scene linear to display color space, with a view transform and look for tone mapping

Convert to Display · CompositorNodeConvertToDisplay · link

ConvertToDisplay(image: Color = (1.0, 1.0, 1.0, 1.0), invert: Bool = false) -> (image: Color)
Convolve Convolves an image with a kernel

Convolve · CompositorNodeConvolve · link

Convolve(
  image: Color = (0.8, 0.8, 0.8, 1.0),
  kernel_data_type: Menu = "Float",
  Float Kernel: Float = 0.0,
  Color Kernel: Color = (0.8, 0.8, 0.8, 1.0),
  normalize_kernel: Bool = true
) -> (image: Color)
CornerPin Plane warp transformation using explicit corner values

Corner Pin · CompositorNodeCornerPin · link

CornerPin(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  upper_left: Vector = (0.0, 1.0),
  upper_right: Vector = (1.0, 1.0),
  lower_left: Vector = (0.0, 0.0),
  lower_right: Vector = (1.0, 0.0),
  interpolation: Menu = "Bilinear",
  extension_x: Menu = "Clip",
  extension_y: Menu = "Clip"
) -> (image: Color, plane: Float)
Crop Crops image to a smaller region, either making the cropped area transparent or resizing the image

Crop · CompositorNodeCrop · link

Crop(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  x: Int = 0,
  y: Int = 0,
  width: Int = 1920,
  height: Int = 1080,
  alpha_crop: Bool = false
) -> (image: Color)
Cryptomatte Generate matte for individual objects and materials using Cryptomatte render passes

Cryptomatte · CompositorNodeCryptomatteV2 · link

Cryptomatte(
  image: Color = (0.0, 0.0, 0.0, 1.0),
  source: RENDER,
  scene: "Scene",
  matte_id: "",
  layer_name: "ViewLayer.CryptoObject",
  frame_duration: 0,
  frame_start: 0,
  frame_offset: 0,
  use_cyclic: false,
  use_auto_refresh: false,
  layer: "",
  view: ""
) -> (image: Color, matte: Float, pick: Color)
SettingValuesDefault
sourceRENDER, IMAGERENDERWhere the Cryptomatte passes are loaded from
scenea Scene, by name"Scene"
imagea Image, by name
matte_idstring""List of object and material crypto IDs to include in matte
layer_nameCryptoObject, CryptoMaterial, CryptoAsset"ViewLayer.CryptoObject"What Cryptomatte layer is used
frame_durationint0Number of images of a movie to use
frame_startint0Global starting frame of the movie/sequence, assuming first picture has a #1
frame_offsetint0Offset the number of the frame to use in the animation
use_cyclicbooleanfalseCycle the images in the movie
use_auto_refreshbooleanfalseAlways refresh image on frame changes
layerPLACEHOLDER""
viewALL""
CryptomatteLegacy Deprecated. Use Cryptomatte Node instead

Cryptomatte (Legacy) · CompositorNodeCryptomatte · link

CryptomatteLegacy(
  image: Color = (0.0, 0.0, 0.0, 1.0),
  crypto_00: Color = (0.8, 0.8, 0.8, 1.0),
  crypto_01: Color = (0.8, 0.8, 0.8, 1.0),
  crypto_02: Color = (0.8, 0.8, 0.8, 1.0),
  matte_id: ""
) -> (image: Color, matte: Float, pick: Color)
SettingValuesDefault
matte_idstring""List of object and material crypto IDs to include in matte
Defocus Apply depth of field in 2D, using a Z depth map or mask

Defocus · CompositorNodeDefocus · link

Defocus(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  z: Float = 1.0,
  bokeh: CIRCLE,
  angle: 0.0,
  f_stop: 128.0,
  blur_max: 16.0,
  use_zbuffer: false,
  z_scale: 1.0
) -> (image: Color)
SettingValuesDefault
scenea Scene, by nameScene from which to select the active camera (render scene if undefined)
bokehOCTAGON, HEPTAGON, HEXAGON, PENTAGON, SQUARE, TRIANGLE, CIRCLECIRCLE
anglefloat0.0Bokeh shape rotation offset
f_stopfloat128.0Amount of focal blur, 128 (infinity) is perfect focus, half the value doubles the blur radius
blur_maxfloat16.0Blur limit, maximum CoC radius
use_zbufferbooleanfalseDisable when using an image as input instead of actual z-buffer (auto enabled if node not image based, eg. time node)
z_scalefloat1.0Scale the Z input when not using a z-buffer, controls maximum blur designated by the color white or input value 1
Denoise Denoise renders from Cycles and other ray tracing renderers

Denoise · CompositorNodeDenoise · link

Denoise(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  albedo: Color = (1.0, 1.0, 1.0, 1.0),
  normal: Vector = (0.0, 0.0, 0.0),
  hdr: Bool = true,
  prefilter: Menu = "Accurate",
  quality: Menu = "Follow Scene"
) -> (image: Color)
DepthCombine Combine two images using depth maps

Depth Combine · CompositorNodeZcombine · link

DepthCombine(
  a: Color = (1.0, 1.0, 1.0, 1.0),
  depth_a: Float = 1.0,
  b: Color = (1.0, 1.0, 1.0, 1.0),
  depth_b: Float = 1.0,
  use_alpha: Bool = false,
  anti_alias: Bool = true
) -> (result: Color, depth: Float)
Despeckle Smooth areas of an image in which noise is noticeable, while leaving complex areas untouched

Despeckle · CompositorNodeDespeckle · link

Despeckle(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  factor: Float = 1.0,
  color_threshold: Float = 0.5,
  neighbor_threshold: Float = 0.5
) -> (image: Color)
DifferenceKey Produce a matte that isolates foreground content by comparing it with a reference background image

Difference Key · CompositorNodeDiffMatte · link

DifferenceKey(
  image_1: Color = (1.0, 1.0, 1.0, 1.0),
  image_2: Color = (1.0, 1.0, 1.0, 1.0),
  tolerance: Float = 0.1,
  falloff: Float = 0.1
) -> (image: Color, matte: Float)
DilateErode Expand and shrink masks

Dilate/Erode · CompositorNodeDilateErode · link

DilateErode(
  mask: Float = 0.0,
  size: Int = 0,
  type: Menu = "Steps",
  falloff_size: Float = 0.0,
  falloff: Menu = "Smooth"
) -> (mask: Float)
DirectionalBlur Blur an image along a direction

Directional Blur · CompositorNodeDBlur · link

DirectionalBlur(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  samples: Int = 1,
  center: Vector = (0.5, 0.5),
  rotation: Float = 0.0,
  scale: Float = 1.0,
  amount: Float = 0.0,
  direction: Float = 0.0
) -> (image: Color)
Displace Displace pixel position using an offset vector

Displace · CompositorNodeDisplace · link

Displace(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  displacement: Vector = (0.0, 0.0),
  interpolation: Menu = "Bilinear",
  extension_x: Menu = "Clip",
  extension_y: Menu = "Clip"
) -> (image: Color)
DistanceKey Create matte based on 3D distance between colors

Distance Key · CompositorNodeDistanceMatte · link

DistanceKey(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  key_color: Color = (1.0, 1.0, 1.0, 1.0),
  color_space: Menu = RGB,
  tolerance: Float = 0.1,
  falloff: Float = 0.1
) -> (image: Color, matte: Float)
DoubleEdgeMask Create a gradient between two masks

Double Edge Mask · CompositorNodeDoubleEdgeMask · link

DoubleEdgeMask(
  outer_mask: Float = 0.8,
  inner_mask: Float = 0.8,
  image_edges: Bool = false,
  only_inside_outer: Bool = false
) -> (mask: Float)
EllipseMask Create elliptical mask suitable for use as a simple matte or vignette mask

Ellipse Mask · CompositorNodeEllipseMask · link

EllipseMask(
  operation: Menu = "Add",
  mask: Float = 0.0,
  value: Float = 1.0,
  position: Vector = (0.5, 0.5),
  size: Vector = (0.2, 0.1),
  rotation: Float = 0.0
) -> (mask: Float)
EnableOutput Either pass through the input value or output the fallback value

Enable Output · NodeEnableOutput · link

EnableOutput(enable: Bool = false, value: Float = 0.0, data_type: FLOAT) -> (value: Float)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, VECTOR, RGBA, ROTATION, MATRIX, STRING, MENU, SHADER, OBJECT, IMAGE, GEOMETRY, COLLECTION, TEXTURE, MATERIAL, BUNDLE, CLOSURE, FONT, SCENE, TEXT, MASK, SOUND, INT_VECTORFLOAT
EulerToRotation Build a rotation from separate angles around each axis

Euler to Rotation · FunctionNodeEulerToRotation · link

EulerToRotation(euler: Vector = (0.0, 0.0, 0.0)) -> (rotation: Rotation)
Exposure Adjust brightness using a camera exposure parameter

Exposure · CompositorNodeExposure · link

Exposure(image: Color = (1.0, 1.0, 1.0, 1.0), exposure: Float = 0.0) -> (image: Color)
FileOutput Write image file to disk

File Output · CompositorNodeOutputFile · link

FileOutput(
  active_item_index: 0,
  directory: "/tmp/",
  file_name: "{blend_name}",
  save_as_render: true,
  use_file_extension: true
)
SettingValuesDefault
active_item_indexint0Index of the active item
directorystring"/tmp/"The directory where the image will be written
file_namestring"{blend_name}"The base name of the file. Other information might be included in the final file name depending on the node options
save_as_renderbooleantrueApply render part of display transform when saving byte image
use_file_extensionbooleantrueAdd the file format extensions to the saved file name (eg: filename + .jpg)
Filter Apply common image enhancement filters

Filter · CompositorNodeFilter · link

Filter(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  factor: Float = 1.0,
  type: Menu = "Soften"
) -> (image: Color)
FindInString Find the number of times a given string occurs in another string and the position of the first match

Find in String · FunctionNodeFindInString · link

FindInString(string: String = "", search: String = "", mode: Menu = "From Start") -> (first_found: Int, count: Int)
Flip Flip an image along a defined axis

Flip · CompositorNodeFlip · link

Flip(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  flip_x: Bool = false,
  flip_y: Bool = false
) -> (image: Color)
FloatCurve Map an input float to a curve and outputs a float value

Float Curve · ShaderNodeFloatCurve · link

FloatCurve(factor: Float = 1.0, value: Float = 1.0) -> (value: Float)

Data: mapping (curves)

FloatToInteger Convert the given floating-point number to an integer, with a choice of methods

Float to Integer · FunctionNodeFloatToInt · link

FloatToInteger(float: Float = 0.0, rounding_mode: ROUND) -> (integer: Int)
SettingValuesDefault
rounding_modeROUND, FLOOR, CEILING, TRUNCATEROUNDMethod used to convert the float to an integer
Font Output a font

Font · GeometryNodeInputFont · link

Font(font: "Bfont Regular") -> (font: Font)
SettingValuesDefault
fonta VectorFont, by name"Bfont Regular"
FormatString Insert values into a string using a Python and path template compatible formatting syntax

Format String · FunctionNodeFormatString · link

FormatString(format: String = "") -> (string: String)
GaborTexture Generate Gabor noise

Gabor Texture · ShaderNodeTexGabor · link

GaborTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  scale: Float = 5.0,
  frequency: Float = 2.0,
  anisotropy: Float = 1.0,
  orientation: Float = 0.785398,
  gabor_type: 2D
) -> (value: Float, phase: Float, intensity: Float)
SettingValuesDefault
gabor_type2D, 3D2DThe type of Gabor noise to evaluate
Gamma Apply a gamma correction

Gamma · ShaderNodeGamma · link

Gamma(color: Color = (1.0, 1.0, 1.0, 1.0), gamma: Float = 1.0) -> (color: Color)
GetBundleItem Retrieve a bundle item by path.

Get Bundle Item · NodeGetBundleItem · link

GetBundleItem(
  bundle: Bundle,
  path: String = "",
  remove: Bool = false,
  socket_type: FLOAT,
  structure_type: AUTO
) -> (bundle: Bundle, item: Float, exists: Bool)
SettingValuesDefault
socket_typeFLOAT, INT, BOOLEAN, VECTOR, RGBA, ROTATION, MATRIX, STRING, MENU, SHADER, OBJECT, IMAGE, GEOMETRY, COLLECTION, TEXTURE, MATERIAL, BUNDLE, CLOSURE, FONT, SCENE, TEXT, MASK, SOUND, INT_VECTORFLOATValue may be implicitly converted if the type does not match
structure_typeAUTO, DYNAMIC, FIELD, GRID, LIST, SINGLEAUTOWhat kind of higher order types are expected to flow through this socket
GetVectorComponent Get the X, Y or Z component of a vector by index

Get Vector Component · FunctionNodeGetVectorComponent · link

GetVectorComponent(vector: Vector = (0.0, 0.0, 0.0), index: Int = 0) -> (value: Float)
Glare Add lens flares, fog and glows around bright parts of the image

Glare · CompositorNodeGlare · link

Glare(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  type: Menu = "Streaks",
  quality: Menu = "Medium",
  threshold: Float = 1.0,
  smoothness: Float = 0.1,
  clamp: Bool = false,
  maximum: Float = 10.0,
  strength: Float = 1.0,
  saturation: Float = 1.0,
  tint: Color = (1.0, 1.0, 1.0, 1.0),
  size: Float = 0.5,
  streaks: Int = 4,
  streaks_angle: Float = 0.0,
  iterations: Int = 3,
  fade: Float = 0.9,
  color_modulation: Float = 0.25,
  diagonal: Bool = true,
  sun_position: Vector = (0.5, 0.5),
  jitter: Float = 0.0,
  kernel_data_type: Menu = "Float",
  Float Kernel: Float = 0.0,
  Color Kernel: Color = (0.8, 0.8, 0.8, 1.0)
) -> (image: Color, glare: Color, highlights: Color)
GradientTexture Generate interpolated color and intensity values based on the input vector

Gradient Texture · ShaderNodeTexGradient · link

GradientTexture(vector: Vector = (0.0, 0.0, 0.0), gradient_type: LINEAR) -> (color: Color, factor: Float)
SettingValuesDefault
gradient_typeLINEAR, QUADRATIC, EASING, DIAGONAL, SPHERICAL, QUADRATIC_SPHERE, RADIALLINEARStyle of the color blending
HashValue Generate a randomized integer using the given input value as a seed

Hash Value · FunctionNodeHashValue · link

HashValue(value: Int = 0, seed: Int = 0, data_type: INT) -> (hash: Int)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, VECTOR, RGBA, ROTATION, MATRIX, STRING, MENU, SHADER, OBJECT, IMAGE, GEOMETRY, COLLECTION, TEXTURE, MATERIAL, BUNDLE, CLOSURE, FONT, SCENE, TEXT, MASK, SOUND, INT_VECTORINT
HueCorrect Adjust hue, saturation, and value with a curve

Hue Correct · CompositorNodeHueCorrect · link

HueCorrect(image: Color = (1.0, 1.0, 1.0, 1.0), factor: Float = 1.0) -> (image: Color)

Data: mapping (curves)

HueSaturationValue Apply a color transformation in the HSV color model

Hue/Saturation/Value · CompositorNodeHueSat · link

HueSaturationValue(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  hue: Float = 0.5,
  saturation: Float = 1.0,
  value: Float = 1.0,
  factor: Float = 1.0
) -> (image: Color)
IDMask Create a matte from an object or material index pass

ID Mask · CompositorNodeIDMask · link

IDMask(id_value: Float = 1.0, index: Int = 0, anti_alias: Bool = false) -> (alpha: Float)
Image Input image or movie file

Image · CompositorNodeImage · link

Image(
  frame_duration: 1,
  frame_start: 1,
  frame_offset: 0,
  use_cyclic: false,
  use_auto_refresh: true,
  layer: "",
  view: ""
) -> (image: Color, alpha: Float)
SettingValuesDefault
imagea Image, by name
frame_durationint1Number of images of a movie to use
frame_startint1Global starting frame of the movie/sequence, assuming first picture has a #1
frame_offsetint0Offset the number of the frame to use in the animation
use_cyclicbooleanfalseCycle the images in the movie
use_auto_refreshbooleantrueAlways refresh image on frame changes
layerPLACEHOLDER""
viewALL""
ImageCoordinates Returns the coordinates of the pixels of an image

Image Coordinates · CompositorNodeImageCoordinates · link

ImageCoordinates(image: Color = (0.8, 0.8, 0.8, 1.0)) -> (uniform: Vector, normalized: Vector, pixel: Int_Vector)
ImageInfo Returns information about an image

Image Info · CompositorNodeImageInfo · link

ImageInfo(image: Color = (0.8, 0.8, 0.8, 1.0)) -> (dimensions: Int_Vector, resolution: Int_Vector, location: Vector, rotation: Float, scale: Vector)
ImportText Import a string from a text file

Import Text · GeometryNodeImportText · link

ImportText(path: String = "") -> (string: String)
IndexSwitch Choose between an arbitrary number of values with an index

Index Switch · GeometryNodeIndexSwitch · link

IndexSwitch(
  index: Int = 0,
  _0: Color = (0.8, 0.8, 0.8, 1.0),
  _1: Color = (0.8, 0.8, 0.8, 1.0),
  data_type: RGBA
) -> (output: Color)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, VECTOR, RGBA, ROTATION, MATRIX, STRING, MENU, SHADER, OBJECT, IMAGE, GEOMETRY, COLLECTION, TEXTURE, MATERIAL, BUNDLE, CLOSURE, FONT, SCENE, TEXT, MASK, SOUND, INT_VECTORRGBA
Inpaint Extend borders of an image into transparent or masked regions

Inpaint · CompositorNodeInpaint · link

Inpaint(image: Color = (1.0, 1.0, 1.0, 1.0), size: Int = 0) -> (image: Color)
Integer Provide an integer value that can be connected to other nodes in the tree

Integer · FunctionNodeInputInt · link

Integer(integer: 0) -> (integer: Int)
SettingValuesDefault
integerint0Input value used for unconnected socket
IntegerMath Perform various math operations on the given integer inputs

Integer Math · FunctionNodeIntegerMath · link

IntegerMath(Value: Int = 0, Value_001: Int = 0, operation: ADD) -> (value: Int)
SettingValuesDefault
operationADD, SUBTRACT, MULTIPLY, DIVIDE, MULTIPLY_ADD, ABSOLUTE, NEGATE, POWER, MINIMUM, MAXIMUM, SIGN, DIVIDE_ROUND, DIVIDE_FLOOR, DIVIDE_CEIL, FLOORED_MODULO, MODULO, GCD, LCMADD
IntegerVector Provide an integer vector value that can be connected to other nodes in the tree

Integer Vector · FunctionNodeInputIntVector · link

IntegerVector(vector_dimensions: 3) -> (vector: Int_Vector)
SettingValuesDefault
vector_dimensionsint3Dimensions of the vector socket
InvertColor Invert colors, producing a negative

Invert Color · CompositorNodeInvert · link

InvertColor(
  color: Color = (1.0, 1.0, 1.0, 1.0),
  factor: Float = 1.0,
  invert_color: Bool = true,
  invert_alpha: Bool = false
) -> (color: Color)
InvertMatrix Compute the inverse of the given matrix, if one exists

Invert Matrix · FunctionNodeInvertMatrix · link

InvertMatrix(matrix: Matrix) -> (matrix: Matrix, invertible: Bool)
InvertRotation Compute the inverse of the given rotation

Invert Rotation · FunctionNodeInvertRotation · link

InvertRotation(rotation: Rotation = (0.0, 0.0, 0.0)) -> (rotation: Rotation)
IsViewport Retrieve whether the nodes are being evaluated for the viewport rather than the final render

Is Viewport · GeometryNodeIsViewport · link

IsViewport() -> (is_viewport: Bool)
Keying Perform both chroma keying (to remove the backdrop) and despill (to correct color cast from the backdrop)

Keying · CompositorNodeKeying · link

Keying(
  image: Color = (0.8, 0.8, 0.8, 1.0),
  key_color: Color = (1.0, 1.0, 1.0, 1.0),
  Preprocess Blur Size: Int = 0,
  Key Balance: Float = 0.5,
  black_level: Float = 0.0,
  white_level: Float = 1.0,
  size: Int = 3,
  tolerance: Float = 0.1,
  garbage_matte: Float = 0.0,
  core_matte: Float = 0.0,
  Postprocess Blur Size: Int = 0,
  dilate_size: Int = 0,
  feather_size: Int = 0,
  feather_falloff: Menu = "Smooth",
  strength: Float = 1.0,
  Despill Balance: Float = 0.5
) -> (image: Color, matte: Float, edges: Float)
KeyingScreen Create plates for use as a color reference for keying nodes

Keying Screen · CompositorNodeKeyingScreen · link

KeyingScreen(smoothness: Float = 0.0, tracking_object: "") -> (screen: Color)
SettingValuesDefault
clipa MovieClip, by name
tracking_objectstring""
Kuwahara Apply smoothing filter that preserves edges, for stylized and painterly effects

Kuwahara · CompositorNodeKuwahara · link

Kuwahara(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  size: Float = 6.0,
  type: Menu = "Anisotropic",
  uniformity: Int = 4,
  sharpness: Float = 1.0,
  eccentricity: Float = 1.0,
  high_precision: Bool = false
) -> (image: Color)
LensDistortion Simulate distortion and dispersion from camera lenses

Lens Distortion · CompositorNodeLensdist · link

LensDistortion(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  type: Menu = "Radial",
  distortion: Float = 0.0,
  dispersion: Float = 0.0,
  jitter: Bool = false,
  fit: Bool = false
) -> (image: Color)
Levels Compute average and standard deviation of pixel values

Levels · CompositorNodeLevels · link

Levels(image: Color = (0.0, 0.0, 0.0, 1.0), channel: Menu = "Combined") -> (mean: Float, standard_deviation: Float, minimum: Float, maximum: Float)
LuminanceKey Create a matte based on luminance (brightness) difference

Luminance Key · CompositorNodeLumaMatte · link

LuminanceKey(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  minimum: Float = 0.0,
  maximum: Float = 1.0
) -> (image: Color, matte: Float)
MagicTexture Generate a psychedelic color texture

Magic Texture · ShaderNodeTexMagic · link

MagicTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  scale: Float = 5.0,
  distortion: Float = 1.0,
  turbulence_depth: 2
) -> (color: Color, factor: Float)
SettingValuesDefault
turbulence_depthint2Level of detail in the added turbulent noise
MapRange Remap a value from a range to a target range

Map Range · ShaderNodeMapRange · link

MapRange(
  value: Float = 1.0,
  from_min: Float = 0.0,
  from_max: Float = 1.0,
  to_min: Float = 0.0,
  to_max: Float = 1.0,
  clamp: true,
  interpolation_type: LINEAR,
  data_type: FLOAT
) -> (result: Float)
SettingValuesDefault
clampbooleantrueClamp the result to the target range [To Min, To Max]
interpolation_typeLINEAR, STEPPED, SMOOTHSTEP, SMOOTHERSTEPLINEAR
data_typeFLOAT, FLOAT_VECTORFLOAT
MapUV Map a texture using UV coordinates, to apply a texture to objects in compositing

Map UV · CompositorNodeMapUV · link

MapUV(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  uv: Vector = (1.0, 0.0, 0.0),
  interpolation: Menu = "Bilinear",
  extension_x: Menu = "Clip",
  extension_y: Menu = "Clip"
) -> (image: Color)
Mask Input mask from a mask data-block, created in the image editor

Mask · CompositorNodeMask · link

Mask(
  size_source: Menu = "Scene Size",
  size_x: Int = 256,
  size_y: Int = 256,
  feather: Bool = true,
  motion_blur: Bool = false,
  samples: Int = 16,
  shutter: Float = 0.5
) -> (mask: Float)
SettingValuesDefault
maska Mask, by name
MaskToSDF Computes a signed distance field from the given mask

Mask To SDF · CompositorNodeMaskToSDF · link

MaskToSDF(mask: Bool = false) -> (sdf: Float, nearest_pixel: Int_Vector)
MatchString Check if a given string exists within another string

Match String · FunctionNodeMatchString · link

MatchString(
  string: String = "",
  operation: Menu = "Starts With",
  key: String = ""
) -> (result: Bool)
Math Perform math operations

Math · ShaderNodeMath · link

Math(
  Value: Float = 0.5,
  Value_001: Float = 0.5,
  operation: ADD,
  use_clamp: false
) -> (value: Float)
SettingValuesDefault
operationADD, SUBTRACT, MULTIPLY, DIVIDE, MULTIPLY_ADD, POWER, LOGARITHM, SQRT, INVERSE_SQRT, ABSOLUTE, EXPONENT, MINIMUM, MAXIMUM, LESS_THAN, GREATER_THAN, SIGN, COMPARE, SMOOTH_MIN, SMOOTH_MAX, ROUND, FLOOR, CEIL, TRUNC, FRACT, MODULO, FLOORED_MODULO, WRAP, SNAP, PINGPONG, SINE, COSINE, TANGENT, ARCSINE, ARCCOSINE, ARCTANGENT, ARCTAN2, SINH, COSH, TANH, RADIANS, DEGREESADD
use_clampbooleanfalseClamp result of the node to 0.0 to 1.0 range
MatrixDeterminant Compute the determinant of the given matrix

Matrix Determinant · FunctionNodeMatrixDeterminant · link

MatrixDeterminant(matrix: Matrix) -> (determinant: Float)
MatrixSVD Compute the singular value decomposition of the 3x3 part of a matrix

Matrix SVD · FunctionNodeMatrixSVD · link

MatrixSVD(matrix: Matrix) -> (u: Matrix, s: Vector, v: Matrix)
Mix Mix values by a factor

Mix · ShaderNodeMix · link

Mix(
  factor: Float = 1.0,
  a: Float = 0.0,
  b: Float = 0.0,
  data_type: FLOAT,
  factor_mode: UNIFORM,
  blend_type: MIX,
  clamp_factor: true,
  clamp_result: false
) -> (result: Float)
SettingValuesDefault
data_typeFLOAT, VECTOR, RGBA, ROTATIONFLOAT
factor_modeUNIFORM, NON_UNIFORMUNIFORM
blend_typeMIX, DARKEN, MULTIPLY, BURN, LIGHTEN, SCREEN, DODGE, ADD, OVERLAY, SOFT_LIGHT, LINEAR_LIGHT, DIFFERENCE, EXCLUSION, SUBTRACT, DIVIDE, HUE, SATURATION, COLOR, VALUEMIX
clamp_factorbooleantrueClamp the factor to [0,1] range
clamp_resultbooleanfalseClamp the result to [0,1] range
MixLegacy Mix two input colors

Mix (Legacy) · ShaderNodeMixRGB · link

MixLegacy(
  factor: Float = 0.5,
  color1: Color = (0.5, 0.5, 0.5, 1.0),
  color2: Color = (0.5, 0.5, 0.5, 1.0),
  blend_type: MIX,
  use_alpha: false,
  use_clamp: false
) -> (color: Color)
SettingValuesDefault
blend_typeMIX, DARKEN, MULTIPLY, BURN, LIGHTEN, SCREEN, DODGE, ADD, OVERLAY, SOFT_LIGHT, LINEAR_LIGHT, DIFFERENCE, EXCLUSION, SUBTRACT, DIVIDE, HUE, SATURATION, COLOR, VALUEMIX
use_alphabooleanfalseInclude alpha of second input in this operation
use_clampbooleanfalseClamp result of the node to 0.0 to 1.0 range
MovieClip Input image or movie from a movie clip data-block, typically used for motion tracking

Movie Clip · CompositorNodeMovieClip · link

MovieClip() -> (image: Color, alpha: Float, offset_x: Float, offset_y: Float, scale: Float, angle: Float)
SettingValuesDefault
clipa MovieClip, by name
MovieDistortion Remove lens distortion from footage, using motion tracking camera lens settings

Movie Distortion · CompositorNodeMovieDistortion · link

MovieDistortion(image: Color = (0.8, 0.8, 0.8, 1.0), type: Menu = "Undistort") -> (image: Color)
SettingValuesDefault
clipa MovieClip, by name
MultiplyMatrices Perform a matrix multiplication on two input matrices

Multiply Matrices · FunctionNodeMatrixMultiply · link

MultiplyMatrices(Matrix: Matrix, Matrix_001: Matrix) -> (matrix: Matrix)
NoiseTexture Generate fractal Perlin noise

Noise Texture · ShaderNodeTexNoise · link

NoiseTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  scale: Float = 5.0,
  detail: Float = 2.0,
  roughness: Float = 0.5,
  lacunarity: Float = 2.0,
  distortion: Float = 0.0,
  noise_dimensions: 2D,
  noise_type: FBM,
  normalize: true
) -> (factor: Float, color: Color)
SettingValuesDefault
noise_dimensions1D, 2D, 3D, 4D2DNumber of dimensions to output noise for
noise_typeMULTIFRACTAL, RIDGED_MULTIFRACTAL, HYBRID_MULTIFRACTAL, FBM, HETERO_TERRAINFBMType of the Noise texture
normalizebooleantrueNormalize outputs to 0.0 to 1.0 range
Normal Input normalized normal values to other nodes in the tree

Normal · CompositorNodeNormal · link

Normal() -> (normal: Vector)
Normalize Map values to 0 to 1 range, based on the minimum and maximum pixel values

Normalize · CompositorNodeNormalize · link

Normalize(value: Float = 1.0) -> (value: Float)
Object Output a single object

Object · GeometryNodeInputObject · link

Object() -> (object: Object)
SettingValuesDefault
objecta Object, by name
ObjectInfo Retrieve information from an object

Object Info · GeometryNodeObjectInfo · link

ObjectInfo(object: Object, transform_space: ORIGINAL) -> (transform: Matrix, location: Vector, rotation: Rotation, scale: Vector)
SettingValuesDefault
transform_spaceORIGINAL, RELATIVEORIGINALThe transformation of the vector and geometry outputs
Pixelate Reduce detail in an image by making individual pixels more prominent, for a blocky or mosaic-like appearance

Pixelate · CompositorNodePixelate · link

Pixelate(color: Color = (0.8, 0.8, 0.8, 1.0), size: Int = 1) -> (color: Color)
PlaneTrackDeform Replace flat planes in footage by another image, detected by plane tracks from motion tracking

Plane Track Deform · CompositorNodePlaneTrackDeform · link

PlaneTrackDeform(
  image: Color = (0.8, 0.8, 0.8, 1.0),
  motion_blur: Bool = false,
  samples: Int = 16,
  shutter: Float = 0.5,
  tracking_object: "",
  plane_track_name: ""
) -> (image: Color, plane: Float)
SettingValuesDefault
clipa MovieClip, by name
tracking_objectstring""
plane_track_namestring""
Posterize Reduce number of colors in an image, converting smooth gradients into sharp transitions

Posterize · CompositorNodePosterize · link

Posterize(image: Color = (1.0, 1.0, 1.0, 1.0), steps: Float = 8.0) -> (image: Color)
ProjectPoint Project a point using a matrix, using location, rotation, scale, and perspective divide

Project Point · FunctionNodeProjectPoint · link

ProjectPoint(vector: Vector = (0.0, 0.0, 0.0), transform: Matrix) -> (vector: Vector)
QuaternionToRotation Build a rotation from quaternion components

Quaternion to Rotation · FunctionNodeQuaternionToRotation · link

QuaternionToRotation(w: Float = 1.0, x: Float = 0.0, y: Float = 0.0, z: Float = 0.0) -> (rotation: Rotation)
RGBCurve Apply color corrections for each color channel

RGB Curves · ShaderNodeRGBCurve · link

RGBCurve(factor: Float = 1.0, color: Color = (1.0, 1.0, 1.0, 1.0)) -> (color: Color)

Data: mapping (curves)

RGBCurves Perform level adjustments on each color channel of an image

RGB Curves · CompositorNodeCurveRGB · link

RGBCurves(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  factor: Float = 1.0,
  black_level: Color = (0.0, 0.0, 0.0, 1.0),
  white_level: Color = (1.0, 1.0, 1.0, 1.0)
) -> (image: Color)

Data: mapping (curves)

RGBToBW Convert RGB input into grayscale using luminance

RGB to BW · CompositorNodeRGBToBW · link

RGBToBW(image: Color = (0.8, 0.8, 0.8, 1.0)) -> (val: Float)
RadialTiling Transform Coordinate System for Radial Tiling

Radial Tiling · ShaderNodeRadialTiling · link

RadialTiling(
  vector: Vector = (0.0, 0.0),
  sides: Float = 5.0,
  roundness: Float = 0.0,
  normalize: false
) -> (segment_coordinates: Vector, segment_id: Float, segment_width: Float, segment_rotation: Float)
SettingValuesDefault
normalizebooleanfalseNormalize the X coordinate of the Segment Coordinates output to a [0, 1] interval and offset the Y coordinate into a [0, infinity) interval. When checked, the textures are stretched to fit into each angular segment. When not checked, the parts of the textures that don't fit into each angular segment are cropped
RandomValue Output a randomized value

Random Value · FunctionNodeRandomValue · link

RandomValue(
  min: Float = 0.0,
  max: Float = 1.0,
  id: Int = 0,
  seed: Int = 0,
  data_type: FLOAT
) -> (value: Float)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOATType of data stored in attribute
RelativeToPixel Converts values that are relative to the image size to be in terms of pixels

Relative To Pixel · CompositorNodeRelativeToPixel · link

RelativeToPixel(
  value: Float = 0.0,
  image: Color = (0.8, 0.8, 0.8, 1.0),
  data_type: FLOAT,
  reference_dimension: X
) -> (value: Float)
SettingValuesDefault
data_typeFLOAT, VECTORFLOATThe type of data
reference_dimensionPER_DIMENSION, X, Y, Greater, Smaller, DiagonalXDefines the dimension of the image that the relative value is in reference to
RenderLayers Input render passes from a scene render

Render Layers · CompositorNodeRLayers · link

RenderLayers(scene: "Scene", layer: "ViewLayer") -> (image: Color, alpha: Float)
SettingValuesDefault
scenea Scene, by name"Scene"
layerPLACEHOLDER"ViewLayer"
ReplaceString Replace a given string segment with another

Replace String · FunctionNodeReplaceString · link

ReplaceString(string: String = "", find: String = "", replace: String = "") -> (string: String)
ReverseString Reverse the order of the characters in a string

Reverse String · FunctionNodeReverseString · link

ReverseString(string: String = "") -> (string: String)
Rotate Rotate image by specified angle

Rotate · CompositorNodeRotate · link

Rotate(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  angle: Float = 0.0,
  interpolation: Menu = "Bilinear",
  extension_x: Menu = "Clip",
  extension_y: Menu = "Clip"
) -> (image: Color)
RotateRotation Apply a secondary rotation to a given rotation value

Rotate Rotation · FunctionNodeRotateRotation · link

RotateRotation(
  rotation: Rotation = (0.0, 0.0, 0.0),
  rotate_by: Rotation = (0.0, 0.0, 0.0),
  rotation_space: GLOBAL
) -> (rotation: Rotation)
SettingValuesDefault
rotation_spaceGLOBAL, LOCALGLOBALBase orientation for the rotation
RotateVector Apply a rotation to a given vector

Rotate Vector · FunctionNodeRotateVector · link

RotateVector(
  vector: Vector = (0.0, 0.0, 0.0),
  rotation: Rotation = (0.0, 0.0, 0.0)
) -> (vector: Vector)
Rotation Provide a rotation value that can be connected to other nodes in the tree

Rotation · FunctionNodeInputRotation · link

Rotation() -> (rotation: Rotation)
RotationToAxisAngle Convert a rotation to axis angle components

Rotation to Axis Angle · FunctionNodeRotationToAxisAngle · link

RotationToAxisAngle(rotation: Rotation = (0.0, 0.0, 0.0)) -> (axis: Vector, angle: Float)
RotationToEuler Convert a standard rotation value to an Euler rotation

Rotation to Euler · FunctionNodeRotationToEuler · link

RotationToEuler(rotation: Rotation = (0.0, 0.0, 0.0)) -> (euler: Vector)
RotationToQuaternion Retrieve the quaternion components representing a rotation

Rotation to Quaternion · FunctionNodeRotationToQuaternion · link

RotationToQuaternion(rotation: Rotation = (0.0, 0.0, 0.0)) -> (w: Float, x: Float, y: Float, z: Float)
Scale Change the size of the image

Scale · CompositorNodeScale · link

Scale(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  type: Menu = "Relative",
  x: Float = 1.0,
  y: Float = 1.0,
  frame_type: Menu = "Stretch",
  interpolation: Menu = "Bilinear",
  extension_x: Menu = "Clip",
  extension_y: Menu = "Clip"
) -> (image: Color)
SceneTime Input the current scene time in seconds or frames

Scene Time · CompositorNodeSceneTime · link

SceneTime() -> (seconds: Float, frame: Float)
SeparateBundle Split a bundle into multiple sockets.

Separate Bundle · NodeSeparateBundle · link

SeparateBundle(bundle: Bundle, define_signature: false)
SettingValuesDefault
define_signaturebooleanfalseThis node defines a bundle signature that should be used by other nodes
SeparateColor Split an image into its composite color channels

Separate Color · CompositorNodeSeparateColor · link

SeparateColor(image: Color = (1.0, 1.0, 1.0, 1.0), mode: RGB, ycc_mode: ITUBT709) -> (red: Float, green: Float, blue: Float, alpha: Float)
SettingValuesDefault
modeRGB, HSV, HSL, YCC, YUVRGBMode of color processing
ycc_modeITUBT601, ITUBT709, JFIFITUBT709Color space used for YCbCrA processing
SeparateMatrix Split a 4x4 matrix into its individual values

Separate Matrix · FunctionNodeSeparateMatrix · link

SeparateMatrix(matrix: Matrix) -> (column_1_row_1: Float, column_1_row_2: Float, column_1_row_3: Float, column_1_row_4: Float, column_2_row_1: Float, column_2_row_2: Float, column_2_row_3: Float, column_2_row_4: Float, column_3_row_1: Float, column_3_row_2: Float, column_3_row_3: Float, column_3_row_4: Float, column_4_row_1: Float, column_4_row_2: Float, column_4_row_3: Float, column_4_row_4: Float)
SeparateTransform Split a transformation matrix into a translation vector, a rotation, and a scale vector

Separate Transform · FunctionNodeSeparateTransform · link

SeparateTransform(transform: Matrix) -> (translation: Vector, rotation: Rotation, scale: Vector)
SeparateXYZ Split a vector into its X, Y, and Z components

Separate XYZ · ShaderNodeSeparateXYZ · link

SeparateXYZ(vector: Vector = (0.0, 0.0, 0.0)) -> (x: Float, y: Float, z: Float)
SequencerStripInfo Returns information about the active strip of the modifier

Sequencer Strip Info · CompositorNodeSequencerStripInfo · link

SequencerStripInfo() -> (start_frame: Int, end_frame: Int, location: Vector, rotation: Float, scale: Vector)
SetAlpha Add an alpha channel to an image

Set Alpha · CompositorNodeSetAlpha · link

SetAlpha(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  alpha: Float = 1.0,
  type: Menu = "Apply Mask"
) -> (image: Color)
SetStringCase Convert the case of a string

Set String Case · FunctionNodeSetStringCase · link

SetStringCase(string: String = "", case: Menu = "Uppercase") -> (string: String)
SliceString Extract a string segment from a larger string

Slice String · FunctionNodeSliceString · link

SliceString(string: String = "", position: Int = 0, length: Int = 10) -> (string: String)
SpecialCharacters Output string characters that cannot be typed directly with the keyboard

Special Characters · FunctionNodeInputSpecialCharacters · link

SpecialCharacters() -> (line_break: String, tab: String)
Split Combine two images for side-by-side display. Typically used in combination with a Viewer node

Split · CompositorNodeSplit · link

Split(
  position: Vector = (0.5, 0.5),
  rotation: Float = 0.785398,
  Image: Color = (0.8, 0.8, 0.8, 1.0),
  Image_001: Color = (0.8, 0.8, 0.8, 1.0)
) -> (image: Color)
Stabilize2D Stabilize footage using 2D stabilization motion tracking settings

Stabilize 2D · CompositorNodeStabilize · link

Stabilize2D(
  image: Color = (0.8, 0.8, 0.8, 1.0),
  frame: Int = 0,
  invert: Bool = false,
  interpolation: Menu = "Bilinear",
  extension_x: Menu = "Clip",
  extension_y: Menu = "Clip"
) -> (image: Color)
SettingValuesDefault
clipa MovieClip, by name
StoreBundleItem Store a bundle item by path and data type.

Store Bundle Item · NodeStoreBundleItem · link

StoreBundleItem(
  bundle: Bundle,
  path: String = "",
  item: Float = 0.0,
  socket_type: FLOAT,
  structure_type: AUTO
) -> (bundle: Bundle)
SettingValuesDefault
socket_typeFLOAT, INT, BOOLEAN, VECTOR, RGBA, ROTATION, MATRIX, STRING, MENU, SHADER, OBJECT, IMAGE, GEOMETRY, COLLECTION, TEXTURE, MATERIAL, BUNDLE, CLOSURE, FONT, SCENE, TEXT, MASK, SOUND, INT_VECTORFLOAT
structure_typeAUTO, DYNAMIC, FIELD, GRID, LIST, SINGLEAUTOWhat kind of higher order types are expected to flow through this socket
String Provide a string value that can be connected to other nodes in the tree

String · FunctionNodeInputString · link

String(string: "") -> (string: String)
SettingValuesDefault
stringstring""
StringLength Output the number of characters in the given string

String Length · FunctionNodeStringLength · link

StringLength(string: String = "") -> (length: Int)
StringToImage Generates an image containing the given paragraph of text

String To Image · CompositorNodeStringToImage · link

StringToImage(
  string: String = "",
  font: Font = "Bfont Regular",
  size: Float = 128.0,
  horizontal_alignment: Menu = "Center",
  vertical_alignment: Menu = "Middle",
  wrap: Bool = true,
  width: Int = 1920
) -> (image: Float)
StringToValue Derive a numeric value from a given string representation

String to Value · FunctionNodeStringToValue · link

StringToValue(string: String = "", data_type: FLOAT) -> (value: Float, length: Int)
SettingValuesDefault
data_typeFLOAT, INTFLOAT
Switch Switch between two inputs

Switch · GeometryNodeSwitch · link

Switch(
  switch: Bool = false,
  false_: Color = (0.8, 0.8, 0.8, 1.0),
  true_: Color = (0.8, 0.8, 0.8, 1.0),
  input_type: RGBA
) -> (output: Color)
SettingValuesDefault
input_typeFLOAT, INT, BOOLEAN, VECTOR, RGBA, ROTATION, MATRIX, STRING, MENU, SHADER, OBJECT, IMAGE, GEOMETRY, COLLECTION, TEXTURE, MATERIAL, BUNDLE, CLOSURE, FONT, SCENE, TEXT, MASK, SOUND, INT_VECTORRGBA
SwitchView Combine the views (left and right) into a single stereo 3D output

Switch View · CompositorNodeSwitchView · link

SwitchView(
  left: Color = (0.0, 0.0, 0.0, 1.0),
  right: Color = (0.0, 0.0, 0.0, 1.0)
) -> (image: Color)
TimeCurve Generate a factor value (from 0.0 to 1.0) between scene start and end time, using a curve mapping

Time Curve · CompositorNodeTime · link

TimeCurve(start_frame: Int = 1, end_frame: Int = 250) -> (factor: Float)

Data: curve (curves)

Tonemap Map one set of colors to another in order to approximate the appearance of high dynamic range

Tonemap · CompositorNodeTonemap · link

Tonemap(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  type: Menu = "R/D Photoreceptor",
  key: Float = 0.18,
  balance: Float = 1.0,
  gamma: Float = 1.0,
  intensity: Float = 0.0,
  contrast: Float = 0.0,
  light_adaptation: Float = 0.0,
  chromatic_adaptation: Float = 0.0
) -> (image: Color)
TrackPosition Provide information about motion tracking points, such as x and y values

Track Position · CompositorNodeTrackPos · link

TrackPosition(
  mode: Menu = "Absolute",
  frame: Int = 0,
  tracking_object: "",
  track_name: ""
) -> (x: Float, y: Float, speed: Vector)
SettingValuesDefault
clipa MovieClip, by name
tracking_objectstring""
track_namestring""
Transform Scale, translate and rotate an image

Transform · CompositorNodeTransform · link

Transform(
  image: Color = (0.8, 0.8, 0.8, 1.0),
  x: Float = 0.0,
  y: Float = 0.0,
  angle: Float = 0.0,
  scale: Float = 1.0,
  interpolation: Menu = "Bilinear",
  extension_x: Menu = "Clip",
  extension_y: Menu = "Clip"
) -> (image: Color)
TransformDirection Apply a transformation matrix (excluding translation) to the given vector

Transform Direction · FunctionNodeTransformDirection · link

TransformDirection(direction: Vector = (0.0, 0.0, 0.0), transform: Matrix) -> (direction: Vector)
TransformPoint Apply a transformation matrix to the given vector

Transform Point · FunctionNodeTransformPoint · link

TransformPoint(vector: Vector = (0.0, 0.0, 0.0), transform: Matrix) -> (vector: Vector)
Translate Offset an image

Translate · CompositorNodeTranslate · link

Translate(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  x: Float = 0.0,
  y: Float = 0.0,
  interpolation: Menu = "Bilinear",
  extension_x: Menu = "Clip",
  extension_y: Menu = "Clip"
) -> (image: Color)
TransposeMatrix Flip a matrix over its diagonal, turning columns into rows and vice-versa

Transpose Matrix · FunctionNodeTransposeMatrix · link

TransposeMatrix(matrix: Matrix) -> (matrix: Matrix)
TrimString Remove characters from the beginning and end of a string

Trim String · FunctionNodeTrimString · link

TrimString(
  string: String = "",
  characters: String = "",
  whitespace: Bool = true,
  start: Bool = true,
  end: Bool = true
) -> (string: String)
Value Input numerical values to other nodes in the tree

Value · ShaderNodeValue · link

Value() -> (value: Float)
ValueToString Generate a string representation of the given input value

Value to String · FunctionNodeValueToString · link

ValueToString(value: Float = 0.0, decimals: Int = 0, data_type: FLOAT) -> (string: String)
SettingValuesDefault
data_typeFLOAT, INTFLOAT
Vector Provide a vector value that can be connected to other nodes in the tree

Vector · FunctionNodeInputVector · link

Vector(vector_dimensions: 3) -> (vector: Vector)
SettingValuesDefault
vector_dimensionsint3Dimensions of the vector socket
VectorBlur Uses the vector speed render pass to blur the image pixels in 2D

Vector Blur · CompositorNodeVecBlur · link

VectorBlur(
  image: Color = (1.0, 1.0, 1.0, 1.0),
  speed: Vector = (0.0, 0.0, 0.0, 0.0),
  depth: Float = 0.0,
  samples: Int = 32,
  shutter: Float = 0.5
) -> (image: Color)
VectorCurves Map input vector components with curves

Vector Curves · ShaderNodeVectorCurve · link

VectorCurves(factor: Float = 1.0, vector: Vector = (0.0, 0.0, 0.0)) -> (vector: Vector)

Data: mapping (curves)

VectorMath Perform vector math operation

Vector Math · ShaderNodeVectorMath · link

VectorMath(
  Vector: Vector = (0.0, 0.0, 0.0),
  Vector_001: Vector = (0.0, 0.0, 0.0),
  operation: ADD
) -> (vector: Vector)
SettingValuesDefault
operationADD, SUBTRACT, MULTIPLY, DIVIDE, MULTIPLY_ADD, CROSS_PRODUCT, PROJECT, REFLECT, REFRACT, FACEFORWARD, DOT_PRODUCT, DISTANCE, LENGTH, SCALE, NORMALIZE, ABSOLUTE, POWER, SIGN, MINIMUM, MAXIMUM, ROUND, FLOOR, CEIL, FRACTION, MODULO, WRAP, SNAP, SINE, COSINE, TANGENTADD
VectorRotate Rotate a vector around a pivot point (center)

Vector Rotate · ShaderNodeVectorRotate · link

VectorRotate(
  vector: Vector = (0.0, 0.0, 0.0),
  center: Vector = (0.0, 0.0, 0.0),
  axis: Vector = (0.0, 0.0, 1.0),
  angle: Float = 0.0,
  rotation_type: AXIS_ANGLE,
  invert: false
) -> (vector: Vector)
SettingValuesDefault
rotation_typeAXIS_ANGLE, X_AXIS, Y_AXIS, Z_AXIS, EULER_XYZAXIS_ANGLEType of angle input
invertbooleanfalseInvert the rotation angle
Viewer Visualize data from inside a node graph, in the image editor or as a backdrop

Viewer · CompositorNodeViewer · link

Viewer(image: Color = (0.0, 0.0, 0.0, 1.0), ui_shortcut: 0)
SettingValuesDefault
ui_shortcutint0
VoronoiTexture Generate Worley noise based on the distance to random points. Typically used to generate textures such as stones, water, or biological cells

Voronoi Texture · ShaderNodeTexVoronoi · link

VoronoiTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  scale: Float = 5.0,
  detail: Float = 0.0,
  roughness: Float = 0.5,
  lacunarity: Float = 2.0,
  randomness: Float = 1.0,
  voronoi_dimensions: 2D,
  distance: EUCLIDEAN,
  feature: F1,
  normalize: false
) -> (distance: Float, color: Color, position: Vector)
SettingValuesDefault
voronoi_dimensions1D, 2D, 3D, 4D2DNumber of dimensions to output noise for
distanceEUCLIDEAN, MANHATTAN, CHEBYCHEV, MINKOWSKIEUCLIDEANThe distance metric used to compute the texture
featureF1, F2, SMOOTH_F1, DISTANCE_TO_EDGE, N_SPHERE_RADIUSF1The Voronoi feature that the node will compute
normalizebooleanfalseNormalize output Distance to 0.0 to 1.0 range
Warning Create custom warnings in node groups

Warning · GeometryNodeWarning · link

Warning(show: Bool = true, message: String = "", warning_type: ERROR) -> (show: Bool)
SettingValuesDefault
warning_typeERROR, WARNING, INFOERROR
WaveTexture Generate procedural bands or rings with noise

Wave Texture · ShaderNodeTexWave · link

WaveTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  scale: Float = 5.0,
  distortion: Float = 0.0,
  detail: Float = 2.0,
  detail_scale: Float = 1.0,
  detail_roughness: Float = 0.5,
  phase_offset: Float = 0.0,
  wave_type: BANDS,
  bands_direction: X,
  rings_direction: X,
  wave_profile: SIN
) -> (color: Color, factor: Float)
SettingValuesDefault
wave_typeBANDS, RINGSBANDS
bands_directionX, Y, Z, DIAGONALX
rings_directionX, Y, Z, SPHERICALX
wave_profileSIN, SAW, TRISIN
WhiteNoiseTexture Calculate a random value or color based on an input seed

White Noise Texture · ShaderNodeTexWhiteNoise · link

WhiteNoiseTexture(vector: Vector = (0.0, 0.0, 0.0), noise_dimensions: 2D) -> (value: Float, color: Color)
SettingValuesDefault
noise_dimensions1D, 2D, 3D, 4D2DNumber of dimensions to output noise for