base-node (.bn) v0.13.1

Nodes of a shader tree

The 135 nodes a shader 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).

AOVOutput Arbitrary Output Variables. Provide custom render passes for arbitrary shader node outputs

AOV Output · ShaderNodeOutputAOV · link

AOVOutput(color: Color = (0.0, 0.0, 0.0, 1.0), value: Float = 0.0, aov_name: "")
SettingValuesDefault
aov_namestring""Name of the AOV that this output writes to
AddShader Add two Shaders together

Add Shader · ShaderNodeAddShader · link

AddShader(Shader: Shader, Shader_001: Shader) -> (shader: Shader)
AmbientOcclusion Compute how much the hemisphere above the shading point is occluded, for example to add weathering effects to corners. Note: For Cycles, this may slow down renders significantly

Ambient Occlusion · ShaderNodeAmbientOcclusion · link

AmbientOcclusion(
  color: Color = (1.0, 1.0, 1.0, 1.0),
  distance: Float = 1.0,
  normal: Vector = (0.0, 0.0, 0.0),
  samples: 16,
  inside: false,
  only_local: false
) -> (color: Color, ao: Float)
SettingValuesDefault
samplesint16Number of rays to trace per shader evaluation
insidebooleanfalseTrace rays towards the inside of the object
only_localbooleanfalseOnly consider the object itself when computing AO
Attribute Retrieve attributes attached to objects or geometry

Attribute · ShaderNodeAttribute · link

Attribute(attribute_type: GEOMETRY, attribute_name: "") -> (color: Color, vector: Vector, factor: Float, alpha: Float)
SettingValuesDefault
attribute_typeGEOMETRY, OBJECT, INSTANCER, VIEW_LAYER, LIGHTGEOMETRYGeneral type of the attribute
attribute_namestring""
Background Add background light emission. Note: This node should only be used for the world surface output

Background · ShaderNodeBackground · link

Background(color: Color = (0.8, 0.8, 0.8, 1.0), strength: Float = 1.0) -> (background: Shader)
Bevel Generates normals with round corners. Note: only supported in Cycles, and may slow down renders

Bevel · ShaderNodeBevel · link

Bevel(radius: Float = 0.05, normal: Vector = (0.0, 0.0, 0.0), samples: 4) -> (normal: Vector)
SettingValuesDefault
samplesint4Number of rays to trace per shader evaluation
Blackbody Convert a blackbody temperature to an RGB value

Blackbody · ShaderNodeBlackbody · link

Blackbody(temperature: Float = 6500.0) -> (color: Color)
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
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 Control the brightness and contrast of the input color

Brightness/Contrast · ShaderNodeBrightContrast · link

BrightnessContrast(
  color: Color = (1.0, 1.0, 1.0, 1.0),
  brightness: Float = 0.0,
  contrast: Float = 0.0
) -> (color: Color)
Bump Generate a perturbed normal from a height texture for bump mapping. Typically used for faking highly detailed surfaces

Bump · ShaderNodeBump · link

Bump(
  strength: Float = 1.0,
  distance: Float = 0.001,
  filter_width: Float = 0.1,
  height: Float = 1.0,
  normal: Vector = (0.0, 0.0, 0.0),
  invert: false
) -> (normal: Vector)
SettingValuesDefault
invertbooleanfalseInvert the bump mapping direction to push into the surface instead of out
CameraData Retrieve information about the camera and how it relates to the current shading point's position

Camera Data · ShaderNodeCameraData · link

CameraData() -> (view_vector: Vector, view_z_depth: Float, view_distance: 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)
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 · ShaderNodeRGB · link

Color() -> (color: Color)
ColorAttribute Retrieve a color attribute, or the default fallback if none is specified

Color Attribute · ShaderNodeVertexColor · link

ColorAttribute(layer_name: "") -> (color: Color, alpha: Float)
SettingValuesDefault
layer_namestring""Color Attribute
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)

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 Create a color from individual components using multiple models

Combine Color · ShaderNodeCombineColor · link

CombineColor(red: Float = 0.0, green: Float = 0.0, blue: Float = 0.0, mode: RGB) -> (color: Color)
SettingValuesDefault
modeRGB, HSV, HSLRGBMode of color processing
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
CurvesInfo Retrieve hair curve information

Curves Info · ShaderNodeHairInfo · link

CurvesInfo() -> (is_strand: Float, intercept: Float, length: Float, thickness: Float, tangent_normal: Vector, random: Float)
DiffuseBSDF Lambertian and Oren-Nayar diffuse reflection

Diffuse BSDF · ShaderNodeBsdfDiffuse · link

DiffuseBSDF(
  color: Color = (0.8, 0.8, 0.8, 1.0),
  roughness: Float = 0.0,
  normal: Vector = (0.0, 0.0, 0.0)
) -> (bsdf: Shader)
Displacement Displace the surface along the surface normal

Displacement · ShaderNodeDisplacement · link

Displacement(
  height: Float = 0.0,
  midlevel: Float = 0.5,
  scale: Float = 0.01,
  normal: Vector = (0.0, 0.0, 0.0),
  space: OBJECT
) -> (displacement: Vector)
SettingValuesDefault
spaceOBJECT, WORLDOBJECTSpace of the input height
Emission Lambertian emission shader

Emission · ShaderNodeEmission · link

Emission(color: Color = (1.0, 1.0, 1.0, 1.0), strength: Float = 1.0) -> (emission: Shader)
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
EnvironmentTexture Sample an image file as an environment texture. Typically used to light the scene with the background node

Environment Texture · ShaderNodeTexEnvironment · link

EnvironmentTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  projection: EQUIRECTANGULAR,
  interpolation: "Linear"
) -> (color: Color)
SettingValuesDefault
imagea Image, by name
projectionEQUIRECTANGULAR, MIRROR_BALLEQUIRECTANGULARProjection of the input image
interpolationLinear, Closest, Cubic, Smart"Linear"Texture interpolation
EvaluateClosure Execute a given closure

Evaluate Closure · NodeEvaluateClosure · link

EvaluateClosure(closure: Closure, define_signature: false)
SettingValuesDefault
define_signaturebooleanfalseThis node defines a closure signature that should be used by other nodes
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)
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)

FormatString Insert values into a string using a Python and path template compatible formatting syntax

Format String · FunctionNodeFormatString · link

FormatString(format: String = "") -> (string: String)
Fresnel Produce a blending factor depending on the angle between the surface normal and the view direction using Fresnel equations. Typically used for mixing reflections at grazing angles

Fresnel · ShaderNodeFresnel · link

Fresnel(ior: Float = 1.5, normal: Vector = (0.0, 0.0, 0.0)) -> (factor: Float)
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)
Geometry Retrieve geometric information about the current shading point

Geometry · ShaderNodeNewGeometry · link

Geometry() -> (position: Vector, normal: Vector, tangent: Vector, true_normal: Vector, incoming: Vector, parametric: Vector, backfacing: Float, pointiness: Float, random_per_island: Float)
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)
GlassBSDF Glass-like shader mixing refraction and reflection at grazing angles

Glass BSDF · ShaderNodeBsdfGlass · link

GlassBSDF(
  color: Color = (1.0, 1.0, 1.0, 1.0),
  roughness: Float = 0.0,
  anisotropy: Float = 0.0,
  rotation: Float = 0.0,
  ior: Float = 1.5,
  normal: Vector = (0.0, 0.0, 0.0),
  tangent: Vector = (0.0, 0.0, 0.0),
  thin_film_thickness: Float = 0.0,
  thin_film_ior: Float = 1.33,
  distribution: MULTI_GGX
) -> (bsdf: Shader)
SettingValuesDefault
distributionBECKMANN, GGX, MULTI_GGXMULTI_GGXLight scattering distribution on rough surface
GlossyBSDF Reflection with microfacet distribution, used for materials such as metal or mirrors

Glossy BSDF · ShaderNodeBsdfAnisotropic · link

GlossyBSDF(
  color: Color = (0.8, 0.8, 0.8, 1.0),
  roughness: Float = 0.5,
  anisotropy: Float = 0.0,
  rotation: Float = 0.0,
  normal: Vector = (0.0, 0.0, 0.0),
  tangent: Vector = (0.0, 0.0, 0.0),
  distribution: MULTI_GGX
) -> (bsdf: Shader)
SettingValuesDefault
distributionBECKMANN, GGX, ASHIKHMIN_SHIRLEY, MULTI_GGXMULTI_GGXLight scattering distribution on rough surface
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
HairBSDF Reflection and transmission shaders optimized for hair rendering

Hair BSDF · ShaderNodeBsdfHair · link

HairBSDF(
  color: Color = (0.8, 0.8, 0.8, 1.0),
  offset: Float = 0.0,
  roughnessu: Float = 0.1,
  roughnessv: Float = 1.0,
  tangent: Vector = (0.0, 0.0, 0.0),
  component: "Reflection"
) -> (bsdf: Shader)
SettingValuesDefault
componentReflection, Transmission"Reflection"Hair BSDF component to use
Holdout Create a "hole" in the image with zero alpha transparency, which is useful for compositing. Note: the holdout shader can only create alpha when transparency is enabled in the film settings

Holdout · ShaderNodeHoldout · link

Holdout() -> (holdout: Shader)
HueSaturationValue Apply a color transformation in the HSV color model

Hue/Saturation/Value · ShaderNodeHueSaturation · link

HueSaturationValue(
  hue: Float = 0.5,
  saturation: Float = 1.0,
  value: Float = 1.0,
  factor: Float = 1.0,
  color: Color = (0.8, 0.8, 0.8, 1.0)
) -> (color: Color)
IESTexture Match real world lights with IES files, which store the directional intensity distribution of light sources

IES Texture · ShaderNodeTexIES · link

IESTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  strength: Float = 1.0,
  filepath: "",
  mode: INTERNAL
) -> (factor: Float)
SettingValuesDefault
iesa Text, by nameInternal IES file
filepathstring""IES light path
modeINTERNAL, EXTERNALINTERNALWhether the IES file is loaded from disk or from a text data-block
ImageTexture Sample an image file as a texture

Image Texture · ShaderNodeTexImage · link

ImageTexture(
  vector: Vector = (0.0, 0.0, 0.0),
  projection: FLAT,
  interpolation: "Linear",
  projection_blend: 0.0,
  extension: REPEAT
) -> (color: Color, alpha: Float)
SettingValuesDefault
imagea Image, by name
projectionFLAT, BOX, SPHERE, TUBEFLATMethod to project 2D image on object with a 3D texture vector
interpolationLinear, Closest, Cubic, Smart"Linear"Texture interpolation
projection_blendfloat0.0For box projection, amount of blend to use between sides
extensionREPEAT, EXTEND, CLIP, MIRRORREPEATHow the image is extrapolated past its original bounds
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
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
InvertColor Invert a color, producing a negative

Invert Color · ShaderNodeInvert · link

InvertColor(factor: Float = 1.0, color: Color = (0.0, 0.0, 0.0, 1.0)) -> (color: Color)
JoinBundle Join multiple bundles together

Join Bundle · NodeJoinBundle · link

JoinBundle(bundle: Bundle) -> (bundle: Bundle)
LayerWeight Produce a blending factor depending on the angle between the surface normal and the view direction. Typically used for layering shaders with the Mix Shader node

Layer Weight · ShaderNodeLayerWeight · link

LayerWeight(blend: Float = 0.5, normal: Vector = (0.0, 0.0, 0.0)) -> (fresnel: Float, facing: Float)
LightAccumulation Adds the result of all the evaluated lights and stores each input into its respective Compositing Pass. The combined result is computed as (Diffuse Light * Diffuse Color) + (Glossy Light * Glossy Color)

Light Accumulation · ShaderNodeLightAccumulation · link

LightAccumulation(
  diffuse_light: Color = (0.0, 0.0, 0.0, 1.0),
  diffuse_color: Color = (1.0, 1.0, 1.0, 1.0),
  glossy_light: Color = (0.0, 0.0, 0.0, 1.0),
  glossy_color: Color = (1.0, 1.0, 1.0, 1.0),
  transmission_light: Color = (0.0, 0.0, 0.0, 1.0),
  transmission_color: Color = (1.0, 1.0, 1.0, 1.0)
) -> (shader: Shader)
LightEvaluation Light Evaluation

Light Evaluation · ShaderNodeLightEvaluation · link

LightEvaluation(
  position: Vector = (0.0, 0.0, 0.0),
  normal: Vector = (0.0, 0.0, 0.0),
  mode: DIFFUSE
) -> (factor: Float, mask: Float, direction: Vector, distance: Float)
SettingValuesDefault
modeDIFFUSE, GLOSSYDIFFUSEDefines parametrization of the light evaluation
LightFalloff Manipulate how light intensity decreases over distance. Typically used for non-physically-based effects; in reality light always falls off quadratically

Light Falloff · ShaderNodeLightFalloff · link

LightFalloff(strength: Float = 100.0, smooth: Float = 0.0) -> (quadratic: Float, linear: Float, constant: Float)
LightInfo Exposes physical properties of the light being evaluated and computes basic information relative to the evaluation position

Light Info · ShaderNodeLightInfo · link

LightInfo() -> (color: Color, power: Float, position: Vector)
LightIterInternalInput Light Iter Internal Input

Light Iter Internal Input · ShaderNodeLightIterInternalInput · link

LightIterInternalInput() -> (lightindex: Int)
LightIterInternalOutput Light Iter Internal Output

Light Iter Internal Output · ShaderNodeLightIterInternalOutput · link

LightIterInternalOutput()
LightOutput Output light information to a light object

Light Output · ShaderNodeOutputLight · link

LightOutput(surface: Shader, is_active_output: true, target: ALL)
SettingValuesDefault
is_active_outputbooleantrueTrue if this node is used as the active output
targetALL, EEVEE, CYCLESALLWhich renderer and viewport shading types to use the shaders for
LightPath Retrieve the type of incoming ray for which the shader is being executed. Typically used for non-physically-based tricks

Light Path · ShaderNodeLightPath · link

LightPath() -> (is_camera_ray: Float, is_shadow_ray: Float, is_diffuse_ray: Float, is_glossy_ray: Float, is_singular_ray: Float, is_reflection_ray: Float, is_transmission_ray: Float, is_volume_scatter_ray: Float, ray_length: Float, ray_depth: Float, diffuse_depth: Float, glossy_depth: Float, transparent_depth: Float, transmission_depth: Float, portal_depth: Float)
LineStyleOutput Control the mixing of texture information into the base color of line styles

Line Style Output · ShaderNodeOutputLineStyle · link

LineStyleOutput(
  color: Color = (1.0, 0.0, 1.0, 1.0),
  color_fac: Float = 1.0,
  alpha: Float = 1.0,
  alpha_fac: Float = 1.0,
  is_active_output: true,
  blend_type: MIX,
  use_alpha: false,
  use_clamp: false
)
SettingValuesDefault
is_active_outputbooleantrueTrue if this node is used as the active output
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
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
Mapping Transform the input vector by applying translation, rotation, and scale

Mapping · ShaderNodeMapping · link

Mapping(
  vector: Vector = (0.0, 0.0, 0.0),
  location: Vector = (0.0, 0.0, 0.0),
  rotation: Vector = (0.0, 0.0, 0.0),
  scale: Vector = (1.0, 1.0, 1.0),
  vector_type: POINT
) -> (vector: Vector)
SettingValuesDefault
vector_typePOINT, TEXTURE, VECTOR, NORMALPOINTType of vector that the mapping transforms
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)
MaterialOutput Output surface material information for use in rendering

Material Output · ShaderNodeOutputMaterial · link

MaterialOutput(
  surface: Shader,
  volume: Shader,
  displacement: Vector = (0.0, 0.0, 0.0),
  thickness: Float = 0.0,
  is_active_output: true,
  target: ALL
)
SettingValuesDefault
is_active_outputbooleantrueTrue if this node is used as the active output
targetALL, EEVEE, CYCLESALLWhich renderer and viewport shading types to use the shaders for
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
MetallicBSDF Metallic reflection with microfacet distribution, and metallic fresnel

Metallic BSDF · ShaderNodeBsdfMetallic · link

MetallicBSDF(
  base_color: Color = (0.617, 0.577, 0.54, 1.0),
  edge_tint: Color = (0.695, 0.726, 0.77, 1.0),
  roughness: Float = 0.5,
  anisotropy: Float = 0.0,
  rotation: Float = 0.0,
  normal: Vector = (0.0, 0.0, 0.0),
  tangent: Vector = (0.0, 0.0, 0.0),
  thin_film_thickness: Float = 0.0,
  thin_film_ior: Float = 1.33,
  distribution: MULTI_GGX,
  fresnel_type: F82
) -> (bsdf: Shader)
SettingValuesDefault
distributionBECKMANN, GGX, MULTI_GGXMULTI_GGXLight scattering distribution on rough surface
fresnel_typePHYSICAL_CONDUCTOR, F82F82Fresnel method used to tint the metal
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
MixShader Mix two shaders together. Typically used for material layering

Mix Shader · ShaderNodeMixShader · link

MixShader(factor: Float = 0.5, Shader: Shader, Shader_001: Shader) -> (shader: Shader)
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: 3D,
  noise_type: FBM,
  normalize: true
) -> (factor: Float, color: Color)
SettingValuesDefault
noise_dimensions1D, 2D, 3D, 4D3DNumber 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 Generate a normal vector and a dot product

Normal · ShaderNodeNormal · link

Normal(normal: Vector = (0.0, 0.0, 1.0)) -> (normal: Vector, dot_: Float)
NormalMap Generate a perturbed normal from an RGB normal map image. Typically used for faking highly detailed surfaces

Normal Map · ShaderNodeNormalMap · link

NormalMap(
  strength: Float = 1.0,
  color: Color = (0.5, 0.5, 1.0, 1.0),
  space: TANGENT,
  uv_map: "",
  convention: OPENGL,
  base: DISPLACED
) -> (normal: Vector)
SettingValuesDefault
spaceTANGENT, OBJECT, WORLD, BLENDER_OBJECT, BLENDER_WORLDTANGENTSpace of the input normal
uv_mapstring""UV Map for tangent space maps
conventionOPENGL, DIRECTXOPENGLOpenGL or DirectX
baseORIGINAL, DISPLACEDDISPLACEDBase surface that the normal map is applied relative to, when displacement is used
ObjectInfo Retrieve information about the object instance

Object Info · ShaderNodeObjectInfo · link

ObjectInfo() -> (location: Vector, color: Color, alpha: Float, object_index: Float, material_index: Float, random: Float)
ParticleInfo Retrieve the data of the particle that spawned the object instance, for example to give variation to multiple instances of an object

Particle Info · ShaderNodeParticleInfo · link

ParticleInfo() -> (index: Float, random: Float, age: Float, lifetime: Float, location: Vector, size: Float, velocity: Vector, angular_velocity: Vector)
PointInfo Retrieve information about points in a point cloud

Point Info · ShaderNodePointInfo · link

PointInfo() -> (position: Vector, radius: Float, random: Float)
PrincipledBSDF Physically-based, easy-to-use shader for rendering surface materials, based on the OpenPBR model

Principled BSDF · ShaderNodeBsdfPrincipled · link

PrincipledBSDF(
  base_color: Color = (0.8, 0.8, 0.8, 1.0),
  metallic: Float = 0.0,
  roughness: Float = 0.5,
  ior: Float = 1.5,
  alpha: Float = 1.0,
  thin_wall: Bool = false,
  normal: Vector = (0.0, 0.0, 0.0),
  diffuse_roughness: Float = 0.0,
  subsurface_weight: Float = 0.0,
  subsurface_radius: Vector = (1.0, 0.2, 0.1),
  subsurface_scale: Float = 0.005,
  subsurface_anisotropy: Float = 0.0,
  specular_ior_level: Float = 0.5,
  specular_tint: Color = (1.0, 1.0, 1.0, 1.0),
  anisotropic: Float = 0.0,
  anisotropic_rotation: Float = 0.0,
  tangent: Vector = (0.0, 0.0, 0.0),
  transmission_weight: Float = 0.0,
  transmission_dispersion_scale: Float = 0.0,
  transmission_dispersion_abbe_number: Float = 20.0,
  coat_weight: Float = 0.0,
  coat_roughness: Float = 0.03,
  coat_ior: Float = 1.5,
  coat_tint: Color = (1.0, 1.0, 1.0, 1.0),
  coat_normal: Vector = (0.0, 0.0, 0.0),
  sheen_weight: Float = 0.0,
  sheen_roughness: Float = 0.5,
  sheen_tint: Color = (1.0, 1.0, 1.0, 1.0),
  emission_color: Color = (1.0, 1.0, 1.0, 1.0),
  emission_strength: Float = 0.0,
  thin_film_thickness: Float = 0.0,
  thin_film_ior: Float = 1.33,
  distribution: MULTI_GGX,
  subsurface_method: RANDOM_WALK
) -> (bsdf: Shader)
SettingValuesDefault
distributionGGX, MULTI_GGXMULTI_GGXLight scattering distribution on rough surface
subsurface_methodBURLEY, RANDOM_WALK, RANDOM_WALK_SKIN, RANDOM_WALK_LEGACYRANDOM_WALKMethod for rendering subsurface scattering
PrincipledHairBSDF Physically-based, easy-to-use shader for rendering hair and fur

Principled Hair BSDF · ShaderNodeBsdfHairPrincipled · link

PrincipledHairBSDF(
  color: Color = (0.017513, 0.005763, 0.002059, 1.0),
  roughness: Float = 0.3,
  radial_roughness: Float = 0.3,
  coat: Float = 0.0,
  ior: Float = 1.55,
  offset: Float = 0.034907,
  random_roughness: Float = 0.0,
  random: Float = 0.0,
  model: CHIANG,
  parametrization: COLOR
) -> (bsdf: Shader)
SettingValuesDefault
modelCHIANG, HUANGCHIANGSelect from Chiang or Huang model
parametrizationABSORPTION, MELANIN, COLORCOLORSelect the shader's color parametrization
PrincipledVolume Combine all volume shading components into a single easy to use node

Principled Volume · ShaderNodeVolumePrincipled · link

PrincipledVolume(
  color: Color = (0.5, 0.5, 0.5, 1.0),
  color_attribute: String = "",
  density: Float = 1.0,
  density_attribute: String = "density",
  anisotropy: Float = 0.0,
  absorption_color: Color = (0.0, 0.0, 0.0, 1.0),
  emission_strength: Float = 0.0,
  emission_color: Color = (1.0, 1.0, 1.0, 1.0),
  blackbody_intensity: Float = 0.0,
  blackbody_tint: Color = (1.0, 1.0, 1.0, 1.0),
  temperature: Float = 1000.0,
  temperature_attribute: String = "temperature"
) -> (volume: Shader)
RGBCurves Apply color corrections for each color channel

RGB Curves · ShaderNodeRGBCurve · link

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

Data: mapping (curves)

RGBToBW Convert a color's luminance to a grayscale value

RGB to BW · ShaderNodeRGBToBW · link

RGBToBW(color: Color = (0.5, 0.5, 0.5, 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
RayPortalBSDF Continue tracing from an arbitrary new position and in a new direction

Ray Portal BSDF · ShaderNodeBsdfRayPortal · link

RayPortalBSDF(
  color: Color = (1.0, 1.0, 1.0, 1.0),
  position: Vector = (0.0, 0.0, 0.0),
  direction: Vector = (0.0, 0.0, 0.0)
) -> (bsdf: Shader)
Raycast Cast rays and retrieve information from the hit point

Raycast · ShaderNodeRaycast · link

Raycast(
  position: Vector = (0.0, 0.0, 0.0),
  direction: Vector = (0.0, 0.0, 0.0),
  length: Float = 1.0,
  only_local: false
) -> (is_hit: Float, self_hit: Float, hit_distance: Float, hit_position: Vector, hit_normal: Vector)
SettingValuesDefault
only_localbooleanfalseOnly raycast against the object itself
RefractionBSDF Glossy refraction with sharp or microfacet distribution, typically used for materials that transmit light

Refraction BSDF · ShaderNodeBsdfRefraction · link

RefractionBSDF(
  color: Color = (1.0, 1.0, 1.0, 1.0),
  roughness: Float = 0.0,
  ior: Float = 1.45,
  normal: Vector = (0.0, 0.0, 0.0),
  distribution: BECKMANN
) -> (bsdf: Shader)
SettingValuesDefault
distributionBECKMANN, GGXBECKMANNLight scattering distribution on rough surface
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)
SceneTime Retrieve the current time in the scene's animation in units of seconds or frames

Scene Time · GeometryNodeInputSceneTime · link

SceneTime() -> (seconds: Float, frame: Float)
Script Generate an OSL shader from a file or text data-block. Note: OSL shaders are not supported on all GPU backends

Script · ShaderNodeScript · link

Script(
  filepath: "",
  mode: INTERNAL,
  use_auto_update: false,
  bytecode: "",
  bytecode_hash: ""
)
SettingValuesDefault
scripta Text, by nameInternal shader script to define the shader
filepathstring""Shader script path
modeINTERNAL, EXTERNALINTERNAL
use_auto_updatebooleanfalseAutomatically update the shader when the .osl file changes (external scripts only)
bytecodestring""Compile bytecode for shader script node
bytecode_hashstring""Hash of compile bytecode, for quick equality checking
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 a color into its individual components using multiple models

Separate Color · ShaderNodeSeparateColor · link

SeparateColor(color: Color = (0.8, 0.8, 0.8, 1.0), mode: RGB) -> (red: Float, green: Float, blue: Float)
SettingValuesDefault
modeRGB, HSV, HSLRGBMode of color processing
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)
SetStringCase Convert the case of a string

Set String Case · FunctionNodeSetStringCase · link

SetStringCase(string: String = "", case: Menu = "Uppercase") -> (string: String)
ShaderToRGB Convert rendering effect (such as light and shadow) to color. Typically used for non-photorealistic rendering, to apply additional effects on the output of BSDFs. Note: only supported in EEVEE

Shader to RGB · ShaderNodeShaderToRGB · link

ShaderToRGB(shader: Shader) -> (color: Color, alpha: Float)
ShadowRaycast Shadow Raycast

Shadow Raycast · ShaderNodeShadowRaycast · link

ShadowRaycast(position: Vector = (0.0, 0.0, 0.0), softness: Float = 1.0) -> (color: Color)
SheenBSDF Reflection for materials such as cloth. Typically mixed with other shaders (such as a Diffuse Shader) and is not particularly useful on its own

Sheen BSDF · ShaderNodeBsdfSheen · link

SheenBSDF(
  color: Color = (0.8, 0.8, 0.8, 1.0),
  roughness: Float = 0.5,
  normal: Vector = (0.0, 0.0, 0.0),
  distribution: MICROFIBER
) -> (bsdf: Shader)
SettingValuesDefault
distributionASHIKHMIN, MICROFIBERMICROFIBERSheen shading model
SkyTexture Generate a procedural sky texture

Sky Texture · ShaderNodeTexSky · link

SkyTexture(
  sky_type: MULTIPLE_SCATTERING,
  sun_disc: true,
  sun_size: 0.009512,
  sun_intensity: 1.0,
  sun_elevation: 0.261799,
  sun_rotation: 0.0,
  altitude: 100.0,
  air_density: 1.0,
  aerosol_density: 1.0,
  ozone_density: 1.0,
  turbidity: 2.2,
  ground_albedo: 0.3
) -> (color: Color)
SettingValuesDefault
sky_typeSINGLE_SCATTERING, MULTIPLE_SCATTERING, PREETHAM, HOSEK_WILKIEMULTIPLE_SCATTERINGWhich sky model should be used
sun_discbooleantrueInclude the sun itself in the output
sun_sizefloat0.009512Size of sun disc
sun_intensityfloat1.0Strength of Sun
sun_elevationfloat0.261799Sun angle from horizon
sun_rotationfloat0.0Rotation of sun around zenith
altitudefloat100.0Height from sea level
air_densityfloat1.0Density of air molecules. 0 means no air, 1 means urban city air
aerosol_densityfloat1.0Density of dust, pollution and water droplets. 0 means no aerosols, 1 means urban city aerosols
ozone_densityfloat1.0Density of ozone layer. 0 means no ozone, 1 means urban city ozone
turbidityfloat2.2Atmospheric turbidity
ground_albedofloat0.3Ground color that is subtly reflected in the sky
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)
SpecularBSDF Similar to the Principled BSDF node but uses the specular workflow instead of metallic, which functions by specifying the facing (along normal) reflection color. Energy is not conserved, so the result may not be physically accurate

Specular BSDF · ShaderNodeEeveeSpecular · link

SpecularBSDF(
  base_color: Color = (0.8, 0.8, 0.8, 1.0),
  specular: Color = (0.03, 0.03, 0.03, 1.0),
  roughness: Float = 0.2,
  emissive_color: Color = (0.0, 0.0, 0.0, 1.0),
  transparency: Float = 0.0,
  normal: Vector = (0.0, 0.0, 0.0),
  clear_coat: Float = 0.0,
  clear_coat_roughness: Float = 0.0,
  clear_coat_normal: Vector = (0.0, 0.0, 0.0)
) -> (bsdf: Shader)
SqueezeValueLegacy Deprecated

Squeeze Value (Legacy) · ShaderNodeSqueeze · link

SqueezeValueLegacy(value: Float = 0.0, width: Float = 1.0, center: Float = 0.0) -> (value: Float)
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)
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
SubsurfaceScattering Subsurface multiple scattering shader to simulate light entering the surface and bouncing internally. Typically used for materials such as skin, wax, marble or milk

Subsurface Scattering · ShaderNodeSubsurfaceScattering · link

SubsurfaceScattering(
  color: Color = (0.8, 0.8, 0.8, 1.0),
  scale: Float = 0.005,
  radius: Vector = (1.0, 0.2, 0.1),
  ior: Float = 1.4,
  roughness: Float = 1.0,
  anisotropy: Float = 0.0,
  normal: Vector = (0.0, 0.0, 0.0),
  falloff: RANDOM_WALK
) -> (bssrdf: Shader)
SettingValuesDefault
falloffBURLEY, RANDOM_WALK, RANDOM_WALK_SKIN, RANDOM_WALK_LEGACYRANDOM_WALKMethod for rendering subsurface scattering
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
Tangent Generate a tangent direction for the Anisotropic BSDF

Tangent · ShaderNodeTangent · link

Tangent(direction_type: RADIAL, axis: Z, uv_map: "") -> (tangent: Vector)
SettingValuesDefault
direction_typeRADIAL, UV_MAPRADIALMethod to use for the tangent
axisX, Y, ZZAxis for radial tangents
uv_mapstring""UV Map for tangent generated from UV
TextureCoordinate Retrieve multiple types of texture coordinates. Typically used as inputs for texture nodes

Texture Coordinate · ShaderNodeTexCoord · link

TextureCoordinate(from_instancer: false) -> (generated: Vector, normal: Vector, uv: Vector, object: Vector, camera: Vector, window: Vector, reflection: Vector)
SettingValuesDefault
objecta Object, by nameUse coordinates from this object (for object texture coordinates output)
from_instancerbooleanfalseUse the parent of the instance object if possible
ToonBSDF Diffuse and Glossy shaders with cartoon light effects

Toon BSDF · ShaderNodeBsdfToon · link

ToonBSDF(
  color: Color = (0.8, 0.8, 0.8, 1.0),
  size: Float = 0.5,
  smooth: Float = 0.0,
  normal: Vector = (0.0, 0.0, 0.0),
  component: DIFFUSE
) -> (bsdf: Shader)
SettingValuesDefault
componentDIFFUSE, GLOSSYDIFFUSEToon BSDF component to use
TranslucentBSDF Lambertian diffuse transmission

Translucent BSDF · ShaderNodeBsdfTranslucent · link

TranslucentBSDF(color: Color = (0.8, 0.8, 0.8, 1.0), normal: Vector = (0.0, 0.0, 0.0)) -> (bsdf: Shader)
TransparentBSDF Transparency without refraction, passing straight through the surface as if there were no geometry

Transparent BSDF · ShaderNodeBsdfTransparent · link

TransparentBSDF(color: Color = (1.0, 1.0, 1.0, 1.0)) -> (bsdf: Shader)
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)
UVAlongStroke UV coordinates that map a texture along the stroke length

UV Along Stroke · ShaderNodeUVAlongStroke · link

UVAlongStroke(use_tips: false) -> (uv: Vector)
SettingValuesDefault
use_tipsbooleanfalseLower half of the texture is for tips of the stroke
UVMap Retrieve a UV map from the geometry, or the default fallback if none is specified

UV Map · ShaderNodeUVMap · link

UVMap(from_instancer: false, uv_map: "") -> (uv: Vector)
SettingValuesDefault
from_instancerbooleanfalseUse the parent of the instance object if possible
uv_mapstring""UV coordinates to be used for mapping
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
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)

VectorDisplacement Displace the surface along an arbitrary direction

Vector Displacement · ShaderNodeVectorDisplacement · link

VectorDisplacement(
  vector: Color = (0.8, 0.8, 0.8, 1.0),
  midlevel: Float = 0.0,
  scale: Float = 0.01,
  space: TANGENT
) -> (displacement: Vector)
SettingValuesDefault
spaceTANGENT, OBJECT, WORLDTANGENTSpace of the input height
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
VectorTransform Convert a vector, point, or normal between world, camera, and object coordinate space

Vector Transform · ShaderNodeVectorTransform · link

VectorTransform(
  vector: Vector = (0.5, 0.5, 0.5),
  vector_type: VECTOR,
  convert_from: WORLD,
  convert_to: OBJECT
) -> (vector: Vector)
SettingValuesDefault
vector_typePOINT, VECTOR, NORMALVECTOR
convert_fromWORLD, OBJECT, CAMERA, LIGHTWORLDSpace to convert from
convert_toWORLD, OBJECT, CAMERA, LIGHTOBJECTSpace to convert to
VolumeAbsorption Absorb light as it passes through the volume

Volume Absorption · ShaderNodeVolumeAbsorption · link

VolumeAbsorption(color: Color = (0.8, 0.8, 0.8, 1.0), density: Float = 1.0) -> (volume: Shader)
VolumeCoefficients Model all three physical processes in a volume, represented by their coefficients

Volume Coefficients · ShaderNodeVolumeCoefficients · link

VolumeCoefficients(
  absorption_coefficients: Vector = (1.0, 1.0, 1.0),
  scatter_coefficients: Vector = (1.0, 1.0, 1.0),
  anisotropy: Float = 0.0,
  emission_coefficients: Vector = (0.0, 0.0, 0.0),
  phase: HENYEY_GREENSTEIN
) -> (volume: Shader)
SettingValuesDefault
phaseHENYEY_GREENSTEIN, FOURNIER_FORAND, DRAINE, RAYLEIGH, MIEHENYEY_GREENSTEINPhase function for the scattered light
VolumeInfo Read volume data attributes from volume grids

Volume Info · ShaderNodeVolumeInfo · link

VolumeInfo() -> (color: Color, density: Float, flame: Float, temperature: Float)
VolumeScatter Scatter light as it passes through the volume, often used to add fog to a scene

Volume Scatter · ShaderNodeVolumeScatter · link

VolumeScatter(
  color: Color = (0.8, 0.8, 0.8, 1.0),
  density: Float = 1.0,
  anisotropy: Float = 0.0,
  phase: HENYEY_GREENSTEIN
) -> (volume: Shader)
SettingValuesDefault
phaseHENYEY_GREENSTEIN, FOURNIER_FORAND, DRAINE, RAYLEIGH, MIEHENYEY_GREENSTEINPhase function for the scattered light
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: 3D,
  distance: EUCLIDEAN,
  feature: F1,
  normalize: false
) -> (distance: Float, color: Color, position: Vector)
SettingValuesDefault
voronoi_dimensions1D, 2D, 3D, 4D3DNumber 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
Wavelength Convert a wavelength value to an RGB value

Wavelength · ShaderNodeWavelength · link

Wavelength(wavelength: Float = 500.0) -> (color: Color)
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: 3D) -> (value: Float, color: Color)
SettingValuesDefault
noise_dimensions1D, 2D, 3D, 4D3DNumber of dimensions to output noise for
Wireframe Retrieve the edges of an object as it appears to Cycles. Note: as meshes are triangulated before being processed by Cycles, topology will always appear triangulated

Wireframe · ShaderNodeWireframe · link

Wireframe(size: Float = 0.01, use_pixel_size: false) -> (factor: Float)
SettingValuesDefault
use_pixel_sizebooleanfalseUse screen pixel size instead of world units
WorldOutput Output light color information to the scene's World

World Output · ShaderNodeOutputWorld · link

WorldOutput(surface: Shader, volume: Shader, is_active_output: true, target: ALL)
SettingValuesDefault
is_active_outputbooleantrueTrue if this node is used as the active output
targetALL, EEVEE, CYCLESALLWhich renderer and viewport shading types to use the shaders for