base-node (.bn) v0.13.1

Nodes of a geometry tree

The 366 nodes a geometry 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).

AccumulateField Add the values of an evaluated field together and output the running total for each element

Accumulate Field · GeometryNodeAccumulateField · link

AccumulateField(
  value: Float = 1.0,
  group_id: Int = 0,
  data_type: FLOAT,
  domain: POINT
) -> (leading: Float, trailing: Float, total: Float)
SettingValuesDefault
data_typeFLOAT, INT, FLOAT_VECTOR, TRANSFORMFLOATType of data that is accumulated
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINT
ActiveCamera Retrieve the scene's active camera

Active Camera · GeometryNodeInputActiveCamera · link

ActiveCamera() -> (active_camera: Object)
ActiveElement Active element indices of the edited geometry, for tool execution

Active Element · GeometryNodeToolActiveElement · link

ActiveElement(domain: POINT) -> (index: Int, exists: Bool)
SettingValuesDefault
domainPOINT, EDGE, FACE, LAYERPOINT
AdvectGrid Move grid values through a velocity field using numerical integration. Supports multiple integration schemes for different accuracy and performance trade-offs

Advect Grid · GeometryNodeGridAdvect · link

AdvectGrid(
  grid: Float = 0.0,
  velocity: Vector = (0.0, 0.0, 0.0),
  time_step: Float = 1.0,
  integration_scheme: Menu = "Runge-Kutta 3",
  limiter: Menu = "Clamp",
  data_type: FLOAT
) -> (grid: 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_VECTORFLOATNode socket data type
AlignEulerToVector Orient an Euler rotation along the given direction

Align Euler to Vector · FunctionNodeAlignEulerToVector · link

AlignEulerToVector(
  rotation: Vector = (0.0, 0.0, 0.0),
  factor: Float = 1.0,
  vector: Vector = (0.0, 0.0, 1.0),
  axis: X,
  pivot_axis: AUTO
) -> (rotation: Vector)
SettingValuesDefault
axisX, Y, ZXAxis to align to the vector
pivot_axisAUTO, X, Y, ZAUTOAxis to rotate around
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
Arc Generate a poly spline arc

Arc · GeometryNodeCurveArc · link

Arc(
  resolution: Int = 16,
  radius: Float = 1.0,
  start_angle: Float = 0.0,
  sweep_angle: Float = 5.497787,
  connect_center: Bool = false,
  invert_arc: Bool = false,
  mode: RADIUS
) -> (curve: Geometry)
SettingValuesDefault
modePOINTS, RADIUSRADIUSMethod used to determine radius and placement
AttributeStatistic Calculate statistics about a data set from a field evaluated on a geometry

Attribute Statistic · GeometryNodeAttributeStatistic · link

AttributeStatistic(
  geometry: Geometry,
  selection: Bool = true,
  attribute: Float = 0.0,
  data_type: FLOAT,
  domain: POINT
) -> (mean: Float, median: Float, sum: Float, min: Float, max: Float, range: Float, standard_deviation: Float, variance: Float)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOATThe data type the attribute is converted to before calculating the results
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINTWhich domain to read the data from
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)
Bake Cache the incoming data so that it can be used without recomputation

Bake · GeometryNodeBake · link

Bake()
BezierSegment Generate a 2D Bézier spline from the given control points and handles

Bézier Segment · GeometryNodeCurvePrimitiveBezierSegment · link

BezierSegment(
  resolution: Int = 16,
  start: Vector = (-1.0, 0.0, 0.0),
  start_handle: Vector = (-0.5, 0.5, 0.0),
  end_handle: Vector = (0.0, 0.0, 0.0),
  end: Vector = (1.0, 0.0, 0.0),
  mode: POSITION
) -> (curve: Geometry)
SettingValuesDefault
modePOSITION, OFFSETPOSITIONMethod used to determine control handles
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)
BlurAttribute Mix attribute values of neighboring elements

Blur Attribute · GeometryNodeBlurAttribute · link

BlurAttribute(
  value: Float = 0.0,
  iterations: Int = 1,
  weight: Float = 1.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_COLORFLOAT
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
BoundingBox Calculate the limits of a geometry's positions and generate a box mesh with those dimensions

Bounding Box · GeometryNodeBoundBox · link

BoundingBox(geometry: Geometry, use_radius: Bool = true) -> (bounding_box: Geometry, min: Vector, max: Vector)
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
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)
CaptureAttribute Store the result of a field on a geometry and output the data as a node socket. Allows remembering or interpolating data as the geometry changes, such as positions before deformation

Capture Attribute · GeometryNodeCaptureAttribute · link

CaptureAttribute(geometry: Geometry, selection: Bool = true, domain: POINT) -> (geometry: Geometry, selection: Bool)
SettingValuesDefault
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINTWhich domain to store the data in
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
ClipGrid Deactivate grid voxels outside minimum and maximum coordinates, setting them to the background value.

Clip Grid · GeometryNodeGridClip · link

ClipGrid(
  grid: Float = 0.0,
  min_x: Int = 0,
  min_y: Int = 0,
  min_z: Int = 0,
  max_x: Int = 32,
  max_y: Int = 32,
  max_z: Int = 32,
  data_type: FLOAT
) -> (grid: 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_VECTORFLOATNode socket data type
ClosureToList Create a list of values

Closure to List · GeometryNodeClosureToList · link

ClosureToList(count: Int = 1, closure: Closure)
ClusterByConnected Group mesh vertices connected by edges when they are within a specified distance

Cluster by Connected · GeometryNodeClusterByConnected · link

ClusterByConnected(
  selection: Bool = true,
  position: Vector = (0.0, 0.0, 0.0),
  distance: Float = 0.001
) -> (cluster_id: Int)
ClusterByDistance Group elements into integer IDs based on proximity of vector values

Cluster by Distance · GeometryNodeClusterByDistance · link

ClusterByDistance(
  selection: Bool = true,
  group_id: Int = 0,
  position: Vector = (0.0, 0.0, 0.0),
  distance: Float = 0.001
) -> (cluster_id: Int)
Collection Output a single collection

Collection · GeometryNodeInputCollection · link

Collection() -> (collection: Collection)
SettingValuesDefault
collectiona Collection, by name
CollectionChildren Retrieve a collection's object and collection children, in a name-based order

Collection Children · GeometryNodeCollectionChildren · link

CollectionChildren(collection: Collection, recursive: Bool = false) -> (collections: Collection, objects: Object)
CollectionInfo Retrieve geometry instances from a collection

Collection Info · GeometryNodeCollectionInfo · link

CollectionInfo(
  collection: Collection,
  separate_children: Bool = false,
  reset_children: Bool = false,
  transform_space: ORIGINAL
) -> (instances: Geometry)
SettingValuesDefault
transform_spaceORIGINAL, RELATIVEORIGINALThe transformation of the instances output. Does not affect the internal geometry
Color Output a color value chosen with the color picker widget

Color · FunctionNodeInputColor · link

Color() -> (color: Color)
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 Combine four channels into a single color, based on a particular color model

Combine Color · FunctionNodeCombineColor · link

CombineColor(
  red: Float = 0.0,
  green: Float = 0.0,
  blue: Float = 0.0,
  alpha: Float = 1.0,
  mode: RGB
) -> (color: Color)
SettingValuesDefault
modeRGB, HSV, HSLRGBMode of color processing
CombineList Combine an arbitrary number of values into a list

Combine List · GeometryNodeCombineList · link

CombineList(_0: Float = 0.0, data_type: FLOAT) -> (list: 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
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
Cone Generate a cone mesh

Cone · GeometryNodeMeshCone · link

Cone(
  vertices: Int = 32,
  side_segments: Int = 1,
  fill_segments: Int = 1,
  radius_top: Float = 0.0,
  radius_bottom: Float = 1.0,
  depth: Float = 2.0,
  fill_type: NGON
) -> (mesh: Geometry, top: Bool, bottom: Bool, side: Bool, uv_map: Vector)
SettingValuesDefault
fill_typeNONE, NGON, TRIANGLE_FANNGON
ConstructCurves Construct curves from raw topology data

Construct Curves · GeometryNodeConstructCurves · link

ConstructCurves(positions: Vector = (0.0, 0.0, 0.0), curve_offsets: Int = 0) -> (curves: Geometry)
ConvexHull Create a mesh that encloses all points in the input geometry with the smallest number of points

Convex Hull · GeometryNodeConvexHull · link

ConvexHull(geometry: Geometry) -> (convex_hull: Geometry)
CornersOfEdge Retrieve face corners connected to edges

Corners of Edge · GeometryNodeCornersOfEdge · link

CornersOfEdge(edge_index: Int = 0, weights: Float = 0.0, sort_index: Int = 0) -> (corner_index: Int, total: Int)
CornersOfFace Retrieve corners that make up a face

Corners of Face · GeometryNodeCornersOfFace · link

CornersOfFace(face_index: Int = 0, weights: Float = 0.0, sort_index: Int = 0) -> (corner_index: Int, total: Int)
CornersOfVertex Retrieve face corners connected to vertices

Corners of Vertex · GeometryNodeCornersOfVertex · link

CornersOfVertex(vertex_index: Int = 0, weights: Float = 0.0, sort_index: Int = 0) -> (corner_index: Int, total: Int)
Cube Generate a cuboid mesh with variable side lengths and subdivisions

Cube · GeometryNodeMeshCube · link

Cube(
  size: Vector = (1.0, 1.0, 1.0),
  vertices_x: Int = 2,
  vertices_y: Int = 2,
  vertices_z: Int = 2
) -> (mesh: Geometry, uv_map: Vector)
CubeGridTopology Create a boolean grid topology with the given dimensions, for use with the Field to Grid node

Cube Grid Topology · GeometryNodeCubeGridTopology · link

CubeGridTopology(
  bounds_min: Vector = (-1.0, -1.0, -1.0),
  bounds_max: Vector = (1.0, 1.0, 1.0),
  resolution_x: Int = 32,
  resolution_y: Int = 32,
  resolution_z: Int = 32,
  min_x: Int = 0,
  min_y: Int = 0,
  min_z: Int = 0
) -> (topology: Bool)
CurveCircle Generate a poly spline circle

Curve Circle · GeometryNodeCurvePrimitiveCircle · link

CurveCircle(resolution: Int = 32, radius: Float = 1.0, mode: RADIUS) -> (curve: Geometry)
SettingValuesDefault
modePOINTS, RADIUSRADIUSMethod used to determine radius and placement
CurveHandlePositions Retrieve the position of each Bézier control point's handles

Curve Handle Positions · GeometryNodeInputCurveHandlePositions · link

CurveHandlePositions(relative: Bool = false) -> (left: Vector, right: Vector)
CurveLength Retrieve the length of all splines added together

Curve Length · GeometryNodeCurveLength · link

CurveLength(curve: Geometry) -> (length: Float)
CurveLine Generate a poly spline line with two points

Curve Line · GeometryNodeCurvePrimitiveLine · link

CurveLine(
  start: Vector = (0.0, 0.0, 0.0),
  end: Vector = (0.0, 0.0, 1.0),
  mode: POINTS
) -> (curve: Geometry)
SettingValuesDefault
modePOINTS, DIRECTIONPOINTSMethod used to determine radius and placement
CurveOfPoint Retrieve the curve a control point is part of

Curve of Point · GeometryNodeCurveOfPoint · link

CurveOfPoint(point_index: Int = 0) -> (curve_index: Int, index_in_curve: Int)
CurveTangent Retrieve the direction of curves at each control point

Curve Tangent · GeometryNodeInputTangent · link

CurveTangent() -> (tangent: Vector)
CurveTilt Retrieve the angle at each control point used to twist the curve's normal around its tangent

Curve Tilt · GeometryNodeInputCurveTilt · link

CurveTilt() -> (tilt: Float)
CurveToMesh Convert curves into a mesh, optionally with a custom profile shape defined by curves

Curve to Mesh · GeometryNodeCurveToMesh · link

CurveToMesh(
  curve: Geometry,
  profile_curve: Geometry,
  scale: Float = 1.0,
  fill_caps: Bool = false,
  miter_scale: Bool = false,
  miter_scale_limit: Float = 2.356194
) -> (mesh: Geometry)
CurveToPoints Generate a point cloud by sampling positions along curves

Curve to Points · GeometryNodeCurveToPoints · link

CurveToPoints(curve: Geometry, count: Int = 10, mode: COUNT) -> (points: Geometry, tangent: Vector, normal: Vector, rotation: Rotation)
SettingValuesDefault
modeEVALUATED, COUNT, LENGTHCOUNTHow to generate points from the input curve
CurvesToGreasePencil Convert the curves in each top-level instance into Grease Pencil layer

Curves to Grease Pencil · GeometryNodeCurvesToGreasePencil · link

CurvesToGreasePencil(
  curves: Geometry,
  selection: Bool = true,
  instances_as_layers: Bool = true
) -> (grease_pencil: Geometry)
Cylinder Generate a cylinder mesh

Cylinder · GeometryNodeMeshCylinder · link

Cylinder(
  vertices: Int = 32,
  side_segments: Int = 1,
  fill_segments: Int = 1,
  radius: Float = 1.0,
  depth: Float = 2.0,
  fill_type: NGON
) -> (mesh: Geometry, top: Bool, side: Bool, bottom: Bool, uv_map: Vector)
SettingValuesDefault
fill_typeNONE, NGON, TRIANGLE_FANNGON
DeactivateVoxels Deactivate selected voxels and tiles

Deactivate Voxels · GeometryNodeGridDeactivateVoxels · link

DeactivateVoxels(grid: Float = 0.0, selection: Bool = true, data_type: FLOAT) -> (grid: 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_VECTORFLOATNode socket data type
DeformCurvesOnSurface Translate and rotate curves based on changes between the object's original and evaluated surface mesh

Deform Curves on Surface · GeometryNodeDeformCurvesOnSurface · link

DeformCurvesOnSurface(curves: Geometry) -> (curves: Geometry)
DeleteGeometry Remove selected elements of a geometry

Delete Geometry · GeometryNodeDeleteGeometry · link

DeleteGeometry(geometry: Geometry, selection: Bool = true, mode: ALL, domain: POINT) -> (geometry: Geometry)
SettingValuesDefault
modeALL, EDGE_FACE, ONLY_FACEALLWhich parts of the mesh component to delete
domainPOINT, EDGE, FACE, CURVE, INSTANCE, LAYERPOINTWhich domain to delete in
DialGizmo Show a dial gizmo in the viewport for a value

Dial Gizmo · GeometryNodeGizmoDial · link

DialGizmo(
  value: Float = 0.0,
  position: Vector = (0.0, 0.0, 0.0),
  up: Vector = (0.0, 0.0, 1.0),
  screen_space: Bool = true,
  radius: Float = 1.0,
  color_id: PRIMARY
) -> (transform: Geometry)
SettingValuesDefault
color_idPRIMARY, SECONDARY, X, Y, ZPRIMARY
DistributePointsInGrid Generate points inside a volume grid

Distribute Points in Grid · GeometryNodeDistributePointsInGrid · link

DistributePointsInGrid(
  grid: Float = 0.0,
  density: Float = 1.0,
  seed: Int = 0,
  mode: DENSITY_RANDOM
) -> (points: Geometry)
SettingValuesDefault
modeDENSITY_RANDOM, DENSITY_GRIDDENSITY_RANDOMMethod to use for scattering points
DistributePointsInVolume Generate points inside a volume

Distribute Points in Volume · GeometryNodeDistributePointsInVolume · link

DistributePointsInVolume(
  volume: Geometry,
  mode: Menu = "Random",
  density: Float = 1.0,
  seed: Int = 0,
  spacing: Vector = (0.3, 0.3, 0.3),
  threshold: Float = 0.1
) -> (points: Geometry)
DistributePointsOnFaces Generate points spread out on the surface of a mesh

Distribute Points on Faces · GeometryNodeDistributePointsOnFaces · link

DistributePointsOnFaces(
  mesh: Geometry,
  selection: Bool = true,
  density: Float = 10.0,
  seed: Int = 0,
  distribute_method: RANDOM,
  use_legacy_normal: false
) -> (points: Geometry, normal: Vector, rotation: Rotation)
SettingValuesDefault
distribute_methodRANDOM, POISSONRANDOMMethod to use for scattering points
use_legacy_normalbooleanfalseOutput the normal and rotation values that have been output before the node started taking smooth normals into account
DomainSize Retrieve the number of elements in a geometry for each attribute domain

Domain Size · GeometryNodeAttributeDomainSize · link

DomainSize(geometry: Geometry, component: MESH) -> (point_count: Int, edge_count: Int, face_count: Int, face_corner_count: Int)
SettingValuesDefault
componentMESH, POINTCLOUD, CURVE, INSTANCES, GREASEPENCIL, VOLUMEMESH
DualMesh Convert Faces into vertices and vertices into faces

Dual Mesh · GeometryNodeDualMesh · link

DualMesh(mesh: Geometry, keep_boundaries: Bool = false) -> (dual_mesh: Geometry)
DuplicateElements Generate an arbitrary number copies of each selected input element

Duplicate Elements · GeometryNodeDuplicateElements · link

DuplicateElements(
  geometry: Geometry,
  selection: Bool = true,
  amount: Int = 1,
  domain: POINT
) -> (geometry: Geometry, duplicate_index: Int)
SettingValuesDefault
domainPOINT, EDGE, FACE, SPLINE, LAYER, INSTANCEPOINTWhich domain to duplicate
EdgeAngle The angle between the normals of connected manifold faces

Edge Angle · GeometryNodeInputMeshEdgeAngle · link

EdgeAngle() -> (unsigned_angle: Float, signed_angle: Float)
EdgeNeighbors Retrieve the number of faces that use each edge as one of their sides

Edge Neighbors · GeometryNodeInputMeshEdgeNeighbors · link

EdgeNeighbors() -> (face_count: Int)
EdgePathsToCurves Output curves following paths across mesh edges

Edge Paths to Curves · GeometryNodeEdgePathsToCurves · link

EdgePathsToCurves(
  mesh: Geometry,
  start_vertices: Bool = true,
  next_vertex_index: Int = -1
) -> (curves: Geometry)
EdgePathsToSelection Output a selection of edges by following paths across mesh edges

Edge Paths to Selection · GeometryNodeEdgePathsToSelection · link

EdgePathsToSelection(start_vertices: Bool = true, next_vertex_index: Int = -1) -> (selection: Bool)
EdgeVertices Retrieve topology information relating to each edge of a mesh

Edge Vertices · GeometryNodeInputMeshEdgeVertices · link

EdgeVertices() -> (vertex_index_1: Int, vertex_index_2: Int, position_1: Vector, position_2: Vector)
EdgesOfCorner Retrieve the edges on both sides of a face corner

Edges of Corner · GeometryNodeEdgesOfCorner · link

EdgesOfCorner(corner_index: Int = 0) -> (next_edge_index: Int, previous_edge_index: Int)
EdgesOfVertex Retrieve the edges connected to each vertex

Edges of Vertex · GeometryNodeEdgesOfVertex · link

EdgesOfVertex(vertex_index: Int = 0, weights: Float = 0.0, sort_index: Int = 0) -> (edge_index: Int, total: Int)
EdgesToFaceGroups Group faces into regions surrounded by the selected boundary edges

Edges to Face Groups · GeometryNodeEdgesToFaceGroups · link

EdgesToFaceGroups(boundary_edges: Bool = true) -> (face_group_id: Int)
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
EndpointSelection Provide a selection for an arbitrary number of endpoints in each spline

Endpoint Selection · GeometryNodeCurveEndpointSelection · link

EndpointSelection(start_size: Int = 1, end_size: Int = 1) -> (selection: Bool)
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)
EvaluateAtIndex Retrieve data of other elements in the context's geometry

Evaluate at Index · GeometryNodeFieldAtIndex · link

EvaluateAtIndex(value: Float = 0.0, index: Int = 0, domain: POINT, data_type: FLOAT) -> (value: Float)
SettingValuesDefault
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINTDomain the field is evaluated in
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOAT
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
EvaluateOnDomain Retrieve values from a field on a different domain besides the domain from the context

Evaluate on Domain · GeometryNodeFieldOnDomain · link

EvaluateOnDomain(value: Float = 0.0, domain: POINT, data_type: FLOAT) -> (value: Float)
SettingValuesDefault
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINTDomain the field is evaluated in
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOAT
ExtrudeMesh Generate new vertices, edges, or faces from selected elements and move them based on an offset while keeping them connected by their boundary

Extrude Mesh · GeometryNodeExtrudeMesh · link

ExtrudeMesh(
  mesh: Geometry,
  selection: Bool = true,
  offset: Vector = (0.0, 0.0, 0.0),
  offset_scale: Float = 1.0,
  individual: Bool = true,
  mode: FACES
) -> (mesh: Geometry, top: Bool, side: Bool)
SettingValuesDefault
modeVERTICES, EDGES, FACESFACES
FaceArea Calculate the surface area of a mesh's faces

Face Area · GeometryNodeInputMeshFaceArea · link

FaceArea() -> (area: Float)
FaceGroupBoundaries Find edges on the boundaries between groups of faces with the same ID value

Face Group Boundaries · GeometryNodeMeshFaceSetBoundaries · link

FaceGroupBoundaries(face_group_id: Int = 0) -> (boundary_edges: Bool)
FaceNeighbors Retrieve topology information relating to each face of a mesh

Face Neighbors · GeometryNodeInputMeshFaceNeighbors · link

FaceNeighbors() -> (vertex_count: Int, face_count: Int)
FaceOfCorner Retrieve the face each face corner is part of

Face of Corner · GeometryNodeFaceOfCorner · link

FaceOfCorner(corner_index: Int = 0) -> (face_index: Int, index_in_face: Int)
FaceSet Each face's sculpt face set value

Face Set · GeometryNodeToolFaceSet · link

FaceSet() -> (face_set: Int, exists: Bool)
FieldAverage Calculate the mean and median of a given field

Field Average · GeometryNodeFieldAverage · link

FieldAverage(
  value: Float = 0.0,
  group_id: Int = 0,
  data_type: FLOAT,
  domain: POINT
) -> (mean: Float, median: Float)
SettingValuesDefault
data_typeFLOAT, FLOAT_VECTORFLOATType of data the outputs are calculated from
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINT
FieldMinAndMax Calculate the minimum and maximum of a given field

Field Min & Max · GeometryNodeFieldMinAndMax · link

FieldMinAndMax(
  value: Float = 0.0,
  group_id: Int = 0,
  data_type: FLOAT,
  domain: POINT
) -> (min: Float, max: Float)
SettingValuesDefault
data_typeFLOAT, INT, FLOAT_VECTORFLOATType of data the outputs are calculated from
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINT
FieldToGrid Create new grids by evaluating new values on an existing volume grid topology

Field to Grid · GeometryNodeFieldToGrid · link

FieldToGrid(topology: Float = 0.0, data_type: 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_VECTORFLOATData type for topology grid
FieldToList Create a list of values

Field to List · GeometryNodeFieldToList · link

FieldToList(count: Int = 1)
FieldVariance Calculate the standard deviation and variance of a given field

Field Variance · GeometryNodeFieldVariance · link

FieldVariance(
  value: Float = 0.0,
  group_id: Int = 0,
  data_type: FLOAT,
  domain: POINT
) -> (standard_deviation: Float, variance: Float)
SettingValuesDefault
data_typeFLOAT, FLOAT_VECTORFLOATType of data the outputs are calculated from
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINT
FillCurve Generate a mesh on the XY plane with faces on the inside of input curves

Fill Curve · GeometryNodeFillCurve · link

FillCurve(
  curve: Geometry,
  group_id: Int = 0,
  mode: Menu = "Triangles",
  fill_rule: Menu = "Even-Odd"
) -> (mesh: Geometry)
FilletCurve Round corners by generating circular arcs on each control point

Fillet Curve · GeometryNodeFilletCurve · link

FilletCurve(
  curve: Geometry,
  radius: Float = 0.25,
  limit_radius: Bool = false,
  mode: Menu = "B\u00e9zier",
  count: Int = 1
) -> (curve: Geometry)
FilterList Remove items from a list

Filter List · GeometryNodeFilterList · link

FilterList(list: Float = 0.0, selection: Bool = true, socket_type: FLOAT) -> (selection: Float, inverted: Float)
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
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)
FlipFaces Reverse the order of the vertices and edges of selected faces, flipping their normal direction

Flip Faces · GeometryNodeFlipFaces · link

FlipFaces(mesh: Geometry, selection: Bool = true) -> (mesh: Geometry)
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)
GeometryMaterials Get a list of the materials used by a geometry component

Geometry Materials · GeometryNodeGeometryMaterials · link

GeometryMaterials(geometry: Geometry, component_type: Menu = "Mesh") -> (materials: Material)
GeometryProximity Compute the closest location on the target geometry

Geometry Proximity · GeometryNodeProximity · link

GeometryProximity(
  geometry: Geometry,
  group_id: Int = 0,
  sample_position: Vector = (0.0, 0.0, 0.0),
  sample_group_id: Int = 0,
  target_element: FACES
) -> (position: Vector, distance: Float, is_valid: Bool)
SettingValuesDefault
target_elementPOINTS, EDGES, FACESFACESElement of the target geometry to calculate the distance from
GeometryToInstance Convert each input geometry into an instance, which can be much faster than the Join Geometry node when the inputs are large

Geometry to Instance · GeometryNodeGeometryToInstance · link

GeometryToInstance(geometry: Geometry) -> (instances: Geometry)
GetAttributeNames Retrieves attribute names as a list of strings

Get Attribute Names · GeometryNodeGetAttributeNames · link

GetAttributeNames(
  geometry: Geometry,
  filter_data_type: Bool = false,
  data_type: Menu = "Float",
  filter_domain: Bool = false,
  domain: Menu = "Point"
) -> (names: String)
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
GetGeometryBundle Get the bundle of a geometry

Get Geometry Bundle · GeometryNodeGetGeometryBundle · link

GetGeometryBundle(geometry: Geometry, remove: Bool = false) -> (geometry: Geometry, bundle: Bundle)
GetGeometryComponent Get a single component of a geometry

Get Geometry Component · GeometryNodeGetGeometryComponent · link

GetGeometryComponent(geometry: Geometry, type: Menu = "Mesh", remove: Bool = true) -> (geometry: Geometry, component: Geometry, exists: Bool)
GetGridNames Retrieves the names of all grids stored in a volume as a list of strings

Get Grid Names · GeometryNodeGetGridNames · link

GetGridNames(volume: Geometry) -> (names: String)
GetListItem Retrieve a value from a list

Get List Item · GeometryNodeListGetItem · link

GetListItem(
  list: Float = 0.0,
  index: Int = 0,
  socket_type: FLOAT,
  structure_type: AUTO
) -> (value: Float)
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
GetNamedGrid Get volume grid from a volume geometry with the specified name

Get Named Grid · GeometryNodeGetNamedGrid · link

GetNamedGrid(
  volume: Geometry,
  name: String = "",
  remove: Bool = true,
  data_type: FLOAT
) -> (volume: Geometry, grid: 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_VECTORFLOATNode socket data type
GetNestedBundlePaths Get paths to items in a nested bundle with a filter

Get Nested Bundle Paths · NodeGetNestedBundlePaths · link

GetNestedBundlePaths(
  bundle: Bundle,
  mode: Menu = "All",
  pattern_mode: Menu = "Exact",
  bundle_type: String = "",
  data_type: Menu = "Float"
) -> (paths: String)
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)
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
GreasePencilColor Retrieve the color of Grease Pencil points and fills

Grease Pencil Color · GeometryNodeGreasePencilColor · link

GreasePencilColor() -> (point: Color, fill: Color)
GreasePencilDrawTime Retrieve information as to when a Grease Pencil curve was drawn

Grease Pencil Draw Time · GeometryNodeGreasePencilDrawTime · link

GreasePencilDrawTime() -> (creation_time: Float, delta_time: Float)
GreasePencilFillID Retrieve information about the grouping of Grease Pencil fills

Grease Pencil Fill ID · GeometryNodeGreasePencilFillID · link

GreasePencilFillID() -> (fill_id: Int)
GreasePencilOpacity Retrieve the opacity of Grease Pencil points and fills

Grease Pencil Opacity · GeometryNodeGreasePencilOpacity · link

GreasePencilOpacity() -> (point: Float, fill: Float)
GreasePencilStrokeSoftness Retrieve the softness of Grease Pencil strokes

Grease Pencil Stroke Softness · GeometryNodeGreasePencilStrokeSoftness · link

GreasePencilStrokeSoftness() -> (softness: Float)
GreasePencilStrokeVisibility Retrieve the visibility of Grease Pencil strokes

Grease Pencil Stroke Visibility · GeometryNodeGreasePencilStrokeVisibility · link

GreasePencilStrokeVisibility() -> (is_hidden: Bool)
GreasePencilToCurves Convert Grease Pencil layers into curve instances

Grease Pencil to Curves · GeometryNodeGreasePencilToCurves · link

GreasePencilToCurves(
  grease_pencil: Geometry,
  selection: Bool = true,
  layers_as_instances: Bool = true
) -> (curves: Geometry)
Grid Generate a planar mesh on the XY plane

Grid · GeometryNodeMeshGrid · link

Grid(
  size_x: Float = 1.0,
  size_y: Float = 1.0,
  vertices_x: Int = 3,
  vertices_y: Int = 3
) -> (mesh: Geometry, uv_map: Vector)
GridCurl Calculate the magnitude and direction of circulation of a directional vector grid

Grid Curl · GeometryNodeGridCurl · link

GridCurl(grid: Vector = (0.0, 0.0, 0.0)) -> (curl: Vector)
GridDilateAndErode Dilate or erode the active regions of a grid. This changes which voxels are active but does not change their values.

Grid Dilate & Erode · GeometryNodeGridDilateAndErode · link

GridDilateAndErode(
  grid: Float = 0.0,
  connectivity: Menu = "Face",
  tiles: Menu = "Preserve",
  steps: Int = 1,
  data_type: FLOAT
) -> (grid: 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_VECTORFLOATNode socket data type
GridDivergence Calculate the flow into and out of each point of a directional vector grid

Grid Divergence · GeometryNodeGridDivergence · link

GridDivergence(grid: Vector = (0.0, 0.0, 0.0)) -> (divergence: Float)
GridGradient Calculate the direction and magnitude of the change in values of a scalar grid

Grid Gradient · GeometryNodeGridGradient · link

GridGradient(grid: Float = 0.0) -> (gradient: Vector)
GridInfo Retrieve information about a volume grid

Grid Info · GeometryNodeGridInfo · link

GridInfo(grid: Float = 0.0, data_type: FLOAT) -> (transform: Matrix, background_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_VECTORFLOATNode socket data type
GridLaplacian Compute the divergence of the gradient of the input grid

Grid Laplacian · GeometryNodeGridLaplacian · link

GridLaplacian(grid: Float = 0.0) -> (laplacian: Float)
GridMean Apply mean (box) filter smoothing to a voxel. The mean value from surrounding voxels in a box-shape defined by the radius replaces the voxel value.

Grid Mean · GeometryNodeGridMean · link

GridMean(
  grid: Float = 0.0,
  width: Int = 1,
  iterations: Int = 1,
  data_type: FLOAT
) -> (grid: 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_VECTORFLOATNode socket data type
GridMedian Apply median (box) filter smoothing to a voxel. The median value from surrounding voxels in a box-shape defined by the radius replaces the voxel value.

Grid Median · GeometryNodeGridMedian · link

GridMedian(
  grid: Float = 0.0,
  width: Int = 1,
  iterations: Int = 1,
  data_type: FLOAT
) -> (grid: 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_VECTORFLOATNode socket data type
GridSolvePoisson Solve the Poisson equation for a scalar field. Computes a grid whose Laplacian equals the input scalar grid.

Grid Solve Poisson · GeometryNodeGridSolvePoisson · link

GridSolvePoisson(
  grid: Float = 0.0,
  max_iterations: Int = 100,
  error_threshold: Float = 0.001,
  threshold_mode: Menu = "Relative",
  boundary: Menu = "Fixed",
  boundary_value: Float = 0.0,
  boundary_gradient: Vector = (0.0, 0.0, 0.0),
  boundary_factor: Float = 0.0
) -> (solution: Float, success: Bool, iterations: Int, absolute_error: Float, relative_error: Float, debug_boundary_value: Float, debug_boundary_gradient: Vector, debug_boundary_factor: Float)
GridToMesh Generate a mesh on the "surface" of a volume grid

Grid to Mesh · GeometryNodeGridToMesh · link

GridToMesh(grid: Float = 0.0, threshold: Float = 0.1, adaptivity: Float = 0.0) -> (mesh: Geometry)
GridToPoints Generate a point cloud from a volume grid's active voxels

Grid to Points · GeometryNodeGridToPoints · link

GridToPoints(grid: Float = 0.0, data_type: FLOAT) -> (points: Geometry, value: Float, x: Int, y: Int, z: Int, is_tile: Bool, extent: 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_VECTORFLOATNode socket data type
GridTopologyBoolean Combine the topology of multiple grids

Grid Topology Boolean · GeometryNodeGridTopologyBoolean · link

GridTopologyBoolean(
  operation: Menu = "Intersect",
  grid_1: Float = 0.0,
  grid_2: Float = 0.0,
  data_type: FLOAT
) -> (grid: 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_VECTORFLOATNode socket data type
HandleTypeSelection Provide a selection based on the handle types of Bézier control points

Handle Type Selection · GeometryNodeCurveHandleTypeSelection · link

HandleTypeSelection(handle_type: AUTO) -> (selection: Bool)
SettingValuesDefault
handle_typeFREE, AUTO, VECTOR, ALIGNAUTO
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
ID Retrieve a stable random identifier value from the "id" attribute on the point domain, or the index if the attribute does not exist

ID · GeometryNodeInputID · link

ID() -> (id: Int)
IcoSphere Generate a spherical mesh that consists of equally sized triangles

Ico Sphere · GeometryNodeMeshIcoSphere · link

IcoSphere(radius: Float = 1.0, subdivisions: Int = 1) -> (mesh: Geometry, uv_map: Vector)
Image Input an image data-block

Image · GeometryNodeInputImage · link

Image() -> (image: Image)
SettingValuesDefault
imagea Image, by name
ImageInfo Retrieve information about an image

Image Info · GeometryNodeImageInfo · link

ImageInfo(image: Image, frame: Int = 0) -> (width: Int, height: Int, has_alpha: Bool, frame_count: Int, fps: Float)
ImageTexture Sample values from an image texture

Image Texture · GeometryNodeImageTexture · link

ImageTexture(
  image: Image,
  vector: Vector = (0.0, 0.0, 0.0),
  frame: Int = 0,
  interpolation: "Linear",
  extension: REPEAT
) -> (color: Color, alpha: Float)
SettingValuesDefault
interpolationLinear, Closest, Cubic"Linear"Method for smoothing values between pixels
extensionREPEAT, EXTEND, CLIP, MIRRORREPEATHow the image is extrapolated past its original bounds
ImportCSV Import geometry from an CSV file

Import CSV · GeometryNodeImportCSV · link

ImportCSV(path: String = "", delimiter: String = ",") -> (point_cloud: Geometry)
ImportOBJ Import geometry from an OBJ file

Import OBJ · GeometryNodeImportOBJ · link

ImportOBJ(path: String = "") -> (instances: Geometry)
ImportPLY Import a point cloud from a PLY file

Import PLY · GeometryNodeImportPLY · link

ImportPLY(path: String = "") -> (geometry: Geometry)
ImportSPZ Import a point cloud object that is rendered as gaussian splat from an SPZ file

Import SPZ · GeometryNodeImportSPZ · link

ImportSPZ(path: String = "") -> (points: Geometry)
ImportSTL Import a mesh from an STL file

Import STL · GeometryNodeImportSTL · link

ImportSTL(path: String = "") -> (mesh: Geometry)
ImportText Import a string from a text file

Import Text · GeometryNodeImportText · link

ImportText(path: String = "") -> (string: String)
ImportVDB Import volume data from a .vdb file

Import VDB · GeometryNodeImportVDB · link

ImportVDB(path: String = "") -> (volume: Geometry)
Index Retrieve an integer value indicating the position of each element in the list, starting at zero

Index · GeometryNodeInputIndex · link

Index() -> (index: Int)
IndexOfNearest Find the nearest element in a group. Similar to the "Sample Nearest" node

Index of Nearest · GeometryNodeIndexOfNearest · link

IndexOfNearest(position: Vector = (0.0, 0.0, 0.0), group_id: Int = 0) -> (index: Int, has_neighbor: Bool)
IndexSwitch Choose between an arbitrary number of values with an index

Index Switch · GeometryNodeIndexSwitch · link

IndexSwitch(index: Int = 0, _0: Float = 0.0, _1: Float = 0.0, data_type: FLOAT) -> (output: 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
InstanceBounds Calculate position bounds of each instance's geometry set

Instance Bounds · GeometryNodeInputInstanceBounds · link

InstanceBounds(use_radius: Bool = true) -> (min: Vector, max: Vector)
InstanceOnPoints Generate a reference to geometry at each of the input points, without duplicating its underlying data

Instance on Points · GeometryNodeInstanceOnPoints · link

InstanceOnPoints(
  points: Geometry,
  selection: Bool = true,
  instance: Geometry,
  pick_instance: Bool = false,
  instance_index: Int = 0,
  rotation: Rotation = (0.0, 0.0, 0.0),
  scale: Vector = (1.0, 1.0, 1.0)
) -> (instances: Geometry)
InstanceReference Output the reference index of the instance

Instance Reference · GeometryNodeInputInstanceReference · link

InstanceReference() -> (reference_index: Int)
InstanceRotation Retrieve the rotation of each instance in the geometry

Instance Rotation · GeometryNodeInputInstanceRotation · link

InstanceRotation() -> (rotation: Rotation)
InstanceScale Retrieve the scale of each instance in the geometry

Instance Scale · GeometryNodeInputInstanceScale · link

InstanceScale() -> (scale: Vector)
InstanceTransform Retrieve the full transformation of each instance in the geometry

Instance Transform · GeometryNodeInstanceTransform · link

InstanceTransform() -> (transform: Matrix)
InstancesToPoints Generate points at the origins of instances. Note: Nested instances are not affected by this node

Instances to Points · GeometryNodeInstancesToPoints · link

InstancesToPoints(
  instances: Geometry,
  selection: Bool = true,
  position: Vector = (0.0, 0.0, 0.0),
  radius: Float = 0.05
) -> (points: Geometry)
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
InterpolateCurves Generate new curves on points by interpolating between existing curves

Interpolate Curves · GeometryNodeInterpolateCurves · link

InterpolateCurves(
  guide_curves: Geometry,
  guide_up: Vector = (0.0, 0.0, 0.0),
  guide_group_id: Int = 0,
  points: Geometry,
  point_up: Vector = (0.0, 0.0, 0.0),
  point_group_id: Int = 0,
  max_neighbors: Int = 4
) -> (curves: Geometry, closest_index: Int, closest_weight: Float)
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)
IsEdgeSmooth Retrieve whether each edge is marked for smooth or split normals

Is Edge Smooth · GeometryNodeInputEdgeSmooth · link

IsEdgeSmooth() -> (smooth: Bool)
IsFacePlanar Retrieve whether all triangles in a face are on the same plane, i.e. whether they have the same normal

Is Face Planar · GeometryNodeInputMeshFaceIsPlanar · link

IsFacePlanar(threshold: Float = 0.01) -> (planar: Bool)
IsFaceSmooth Retrieve whether each face is marked for smooth or sharp normals

Is Face Smooth · GeometryNodeInputShadeSmooth · link

IsFaceSmooth() -> (smooth: Bool)
IsSplineCyclic Retrieve whether each spline endpoint connects to the beginning

Is Spline Cyclic · GeometryNodeInputSplineCyclic · link

IsSplineCyclic() -> (cyclic: Bool)
IsViewport Retrieve whether the nodes are being evaluated for the viewport rather than the final render

Is Viewport · GeometryNodeIsViewport · link

IsViewport() -> (is_viewport: Bool)
JoinBundle Join multiple bundles together

Join Bundle · NodeJoinBundle · link

JoinBundle(bundle: Bundle) -> (bundle: Bundle)
JoinGeometry Merge separately generated geometries into a single one

Join Geometry · GeometryNodeJoinGeometry · link

JoinGeometry(geometry: Geometry) -> (geometry: Geometry)
JoinStrings Combine any number of input strings

Join Strings · GeometryNodeStringJoin · link

JoinStrings(delimiter: String = "", strings: String = "") -> (string: String)
LinearGizmo Show a linear gizmo in the viewport for a value

Linear Gizmo · GeometryNodeGizmoLinear · link

LinearGizmo(
  value: Float = 0.0,
  position: Vector = (0.0, 0.0, 0.0),
  direction: Vector = (0.0, 0.0, 1.0),
  color_id: PRIMARY,
  draw_style: ARROW
) -> (transform: Geometry)
SettingValuesDefault
color_idPRIMARY, SECONDARY, X, Y, ZPRIMARY
draw_styleARROW, CROSS, BOXARROW
ListLength Count how many items are in a given list

List Length · GeometryNodeListLength · link

ListLength(list: Float = 0.0, data_type: FLOAT) -> (length: 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_VECTORFLOAT
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
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)
Material Output a single material

Material · GeometryNodeInputMaterial · link

Material() -> (material: Material)
SettingValuesDefault
materiala Material, by name
MaterialIndex Retrieve the index of the material used for each element in the geometry's list of materials

Material Index · GeometryNodeInputMaterialIndex · link

MaterialIndex() -> (material_index: Int)
MaterialSelection Provide a selection of faces that use the specified material

Material Selection · GeometryNodeMaterialSelection · link

MaterialSelection(material: Material) -> (selection: 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)
MergeByDistance Merge vertices or points within a given distance

Merge by Distance · GeometryNodeMergeByDistance · link

MergeByDistance(
  geometry: Geometry,
  selection: Bool = true,
  mode: Menu = "All",
  distance: Float = 0.001
) -> (geometry: Geometry)
MergeLayers Join groups of Grease Pencil layers into one

Merge Layers · GeometryNodeMergeLayers · link

MergeLayers(
  grease_pencil: Geometry,
  selection: Bool = true,
  mode: Menu = "By Name",
  group_id: Int = 0,
  mode: MERGE_BY_NAME
) -> (grease_pencil: Geometry)
SettingValuesDefault
modeMERGE_BY_NAME, MERGE_BY_IDMERGE_BY_NAMEDetermines how to choose which layers are merged
MergePoints Merge points of a point cloud or mesh based on group ID and selection.

Merge Points · GeometryNodeMergePoints · link

MergePoints(geometry: Geometry, selection: Bool = true, merge_id: Int = 0) -> (geometry: Geometry)
MeshBevel Bevel selected edges or vertices

Mesh Bevel · GeometryNodeMeshBevel · link

MeshBevel(
  mesh: Geometry,
  selection: Bool = true,
  affect_kind: Menu = "Edges",
  start_left_offset: Float = 0.1,
  start_right_offset: Float = 0.1,
  end_left_offset: Float = 0.1,
  end_right_offset: Float = 0.1,
  offset: Float = 0.1,
  miter: Bool = false,
  spread: Float = 0.1,
  segments: Int = 1,
  shape: Float = 0.5,
  profile: Geometry
) -> (mesh: Geometry, vertex_face: Bool, edge_face: Bool, outer_edge: Bool, mid_edge: Bool)
MeshBoolean Cut, subtract, or join multiple mesh inputs

Mesh Boolean · GeometryNodeMeshBoolean · link

MeshBoolean(
  mesh_1: Geometry,
  mesh_2: Geometry,
  operation: DIFFERENCE,
  solver: FLOAT
) -> (mesh: Geometry)
SettingValuesDefault
operationINTERSECT, UNION, DIFFERENCEDIFFERENCE
solverEXACT, FLOAT, MANIFOLDFLOAT
MeshCircle Generate a circular ring of edges

Mesh Circle · GeometryNodeMeshCircle · link

MeshCircle(vertices: Int = 32, radius: Float = 1.0, fill_type: NONE) -> (mesh: Geometry)
SettingValuesDefault
fill_typeNONE, NGON, TRIANGLE_FANNONE
MeshIsland Retrieve information about separate connected regions in a mesh

Mesh Island · GeometryNodeInputMeshIsland · link

MeshIsland() -> (island_index: Int, island_count: Int)
MeshLine Generate vertices in a line and connect them with edges

Mesh Line · GeometryNodeMeshLine · link

MeshLine(
  count: Int = 10,
  start_location: Vector = (0.0, 0.0, 0.0),
  offset: Vector = (0.0, 0.0, 1.0),
  mode: OFFSET,
  count_mode: TOTAL
) -> (mesh: Geometry)
SettingValuesDefault
modeOFFSET, END_POINTSOFFSET
count_modeTOTAL, RESOLUTIONTOTAL
MeshToCurve Generate a curve from a mesh

Mesh to Curve · GeometryNodeMeshToCurve · link

MeshToCurve(mesh: Geometry, selection: Bool = true, mode: EDGES) -> (curve: Geometry)
SettingValuesDefault
modeEDGES, FACESEDGES
MeshToDensityGrid Create a filled volume grid from a mesh

Mesh to Density Grid · GeometryNodeMeshToDensityGrid · link

MeshToDensityGrid(
  mesh: Geometry,
  density: Float = 1.0,
  voxel_size: Float = 0.3,
  gradient_width: Float = 0.2
) -> (density_grid: Float)
MeshToPoints Generate a point cloud from a mesh's vertices

Mesh to Points · GeometryNodeMeshToPoints · link

MeshToPoints(
  mesh: Geometry,
  selection: Bool = true,
  position: Vector = (0.0, 0.0, 0.0),
  radius: Float = 0.05,
  mode: VERTICES
) -> (points: Geometry)
SettingValuesDefault
modeVERTICES, EDGES, FACES, CORNERSVERTICES
MeshToSDFGrid Create a signed distance volume grid from a mesh

Mesh to SDF Grid · GeometryNodeMeshToSDFGrid · link

MeshToSDFGrid(mesh: Geometry, voxel_size: Float = 0.3, band_width: Int = 3) -> (sdf_grid: Float)
MeshToVolume Create a fog volume with the shape of the input mesh's surface

Mesh to Volume · GeometryNodeMeshToVolume · link

MeshToVolume(
  mesh: Geometry,
  density: Float = 1.0,
  resolution_mode: Menu = "Amount",
  voxel_size: Float = 0.3,
  voxel_amount: Float = 64.0,
  interior_band_width: Float = 0.2
) -> (volume: Geometry)
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
MousePosition Retrieve the position of the mouse cursor

Mouse Position · GeometryNodeToolMousePosition · link

MousePosition() -> (mouse_x: Int, mouse_y: Int, region_width: Int, region_height: Int)
MultiplyMatrices Perform a matrix multiplication on two input matrices

Multiply Matrices · FunctionNodeMatrixMultiply · link

MultiplyMatrices(Matrix: Matrix, Matrix_001: Matrix) -> (matrix: Matrix)
NURBSOrder Retrieve how many curve control points influence each evaluated point

NURBS Order · GeometryNodeNURBSOrder · link

NURBSOrder() -> (order: Int)
NURBSWeight Retrieve the influence of each NURBS control point on the curve

NURBS Weight · GeometryNodeNURBSWeight · link

NURBSWeight() -> (weight: Float)
NamedAttribute Retrieve the data of a specified attribute

Named Attribute · GeometryNodeInputNamedAttribute · link

NamedAttribute(name: String = "", data_type: FLOAT) -> (attribute: Float, exists: Bool)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOATThe data type used to read the attribute values
NamedLayerSelection Output a selection of a Grease Pencil layer

Named Layer Selection · GeometryNodeInputNamedLayerSelection · link

NamedLayerSelection(name: String = "") -> (selection: Bool)
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 Retrieve a unit length vector indicating the direction pointing away from the geometry at each element

Normal · GeometryNodeInputNormal · link

Normal(legacy_corner_normals: false) -> (normal: Vector, true_normal: Vector)
SettingValuesDefault
legacy_corner_normalsbooleanfalseAlways use face normals for the face corner domain, matching old behavior of the node
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, as_instance: Bool = false, transform_space: ORIGINAL) -> (transform: Matrix, location: Vector, rotation: Rotation, scale: Vector, geometry: Geometry)
SettingValuesDefault
transform_spaceORIGINAL, RELATIVEORIGINALThe transformation of the vector and geometry outputs
OffsetCornerInFace Retrieve corners in the same face as another

Offset Corner in Face · GeometryNodeOffsetCornerInFace · link

OffsetCornerInFace(corner_index: Int = 0, offset: Int = 0) -> (corner_index: Int)
OffsetPointInCurve Offset a control point index within its curve

Offset Point in Curve · GeometryNodeOffsetPointInCurve · link

OffsetPointInCurve(point_index: Int = 0, offset: Int = 0) -> (is_valid_offset: Bool, point_index: Int)
PackUVIslands Scale islands of a UV map and move them so they fill the UV space as much as possible

Pack UV Islands · GeometryNodeUVPackIslands · link

PackUVIslands(
  uv: Vector = (0.0, 0.0, 0.0),
  selection: Bool = true,
  margin: Float = 0.001,
  rotate: Bool = true,
  method: Menu = "Bounding Box",
  bottom_left: Vector = (0.0, 0.0),
  top_right: Vector = (1.0, 1.0)
) -> (uv: Vector)
Points Generate a point cloud with positions and radii defined by fields

Points · GeometryNodePoints · link

Points(
  count: Int = 1,
  position: Vector = (0.0, 0.0, 0.0),
  radius: Float = 0.1
) -> (points: Geometry)
PointsOfCurve Retrieve a point index within a curve

Points of Curve · GeometryNodePointsOfCurve · link

PointsOfCurve(curve_index: Int = 0, weights: Float = 0.0, sort_index: Int = 0) -> (point_index: Int, total: Int)
PointsToCurves Split all points to curve by its group ID and reorder by weight

Points to Curves · GeometryNodePointsToCurves · link

PointsToCurves(points: Geometry, curve_group_id: Int = 0, weight: Float = 0.0) -> (curves: Geometry)
PointsToSDFGrid Create a signed distance volume grid from points

Points to SDF Grid · GeometryNodePointsToSDFGrid · link

PointsToSDFGrid(points: Geometry, radius: Float = 0.5, voxel_size: Float = 0.3) -> (sdf_grid: Float)
PointsToVertices Generate a mesh vertex for each point cloud point

Points to Vertices · GeometryNodePointsToVertices · link

PointsToVertices(points: Geometry, selection: Bool = true) -> (mesh: Geometry)
PointsToVolume Generate a fog volume sphere around every point

Points to Volume · GeometryNodePointsToVolume · link

PointsToVolume(
  points: Geometry,
  density: Float = 1.0,
  resolution_mode: Menu = "Amount",
  voxel_size: Float = 0.3,
  voxel_amount: Float = 64.0,
  radius: Float = 0.5
) -> (volume: Geometry)
Position Retrieve a vector indicating the location of each element

Position · GeometryNodeInputPosition · link

Position() -> (position: Vector)
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)
PruneGrid Make the storage of a volume grid more efficient by collapsing data into tiles or inner nodes

Prune Grid · GeometryNodeGridPrune · link

PruneGrid(
  grid: Float = 0.0,
  mode: Menu = "Threshold",
  threshold: Float = 0.01,
  data_type: FLOAT
) -> (grid: 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_VECTORFLOATNode socket data type
QuadraticBezier Generate a poly spline in a parabola shape with control points positions

Quadratic Bézier · GeometryNodeCurveQuadraticBezier · link

QuadraticBezier(
  resolution: Int = 16,
  start: Vector = (-1.0, 0.0, 0.0),
  middle: Vector = (0.0, 2.0, 0.0),
  end: Vector = (1.0, 0.0, 0.0)
) -> (curve: Geometry)
Quadrilateral Generate a polygon with four points

Quadrilateral · GeometryNodeCurvePrimitiveQuadrilateral · link

Quadrilateral(width: Float = 2.0, height: Float = 2.0, mode: RECTANGLE) -> (curve: Geometry)
SettingValuesDefault
modeRECTANGLE, PARALLELOGRAM, TRAPEZOID, KITE, POINTSRECTANGLE
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)
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)

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
Radius Retrieve the radius at each point on curve or point cloud geometry

Radius · GeometryNodeInputRadius · link

Radius() -> (radius: Float)
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
RasterizePoints Create volume grids from points with a weighted sum

Rasterize Points · GeometryNodeRasterizePoints · link

RasterizePoints(
  points: Geometry,
  grid_transform_mode: Menu = "Voxel Size",
  voxel_size: Float = 0.3,
  matrix: Matrix,
  kernel_type: Menu = "Linear",
  position: Vector = (0.0, 0.0, 0.0)
)
Raycast Cast rays from the context geometry onto a target geometry, and retrieve information from each hit point

Raycast · GeometryNodeRaycast · link

Raycast(
  target_geometry: Geometry,
  attribute: Float = 0.0,
  interpolation: Menu = "Interpolated",
  source_position: Vector = (0.0, 0.0, 0.0),
  ray_direction: Vector = (0.0, 0.0, -1.0),
  ray_length: Float = 100.0,
  data_type: FLOAT
) -> (is_hit: Bool, hit_position: Vector, hit_normal: Vector, hit_distance: Float, attribute: 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
RealizeInstances Convert instances into real geometry data

Realize Instances · GeometryNodeRealizeInstances · link

RealizeInstances(
  geometry: Geometry,
  selection: Bool = true,
  realize_all: Bool = true,
  depth: Int = 0,
  preserve_normals: Bool = false,
  realize_to_point_domain: false
) -> (geometry: Geometry)
SettingValuesDefault
realize_to_point_domainbooleanfalsePropagate instance attributes to the point domain rather than the curve domain. This property exists for compatibility with 5.0 and earlier.
RemoveNamedAttribute Delete an attribute with a specified name from a geometry. Typically used to optimize performance

Remove Named Attribute · GeometryNodeRemoveAttribute · link

RemoveNamedAttribute(geometry: Geometry, pattern_mode: Menu = "Exact", name: String = "") -> (geometry: Geometry)
RenameAttribute Change the name of an attribute

Rename Attribute · GeometryNodeRenameAttribute · link

RenameAttribute(
  geometry: Geometry,
  mode: Menu = "Single",
  old: String = "",
  new: String = "",
  overwrite: Bool = false
) -> (geometry: Geometry)
ReplaceMaterial Swap one material with another

Replace Material · GeometryNodeReplaceMaterial · link

ReplaceMaterial(geometry: Geometry, old: Material, new: Material) -> (geometry: Geometry)
ReplaceString Replace a given string segment with another

Replace String · FunctionNodeReplaceString · link

ReplaceString(string: String = "", find: String = "", replace: String = "") -> (string: String)
ResampleCurve Generate a poly spline for each input spline

Resample Curve · GeometryNodeResampleCurve · link

ResampleCurve(
  curve: Geometry,
  selection: Bool = true,
  mode: Menu = "Count",
  count: Int = 10,
  length: Float = 0.1,
  keep_last_segment: true
) -> (curve: Geometry)
SettingValuesDefault
keep_last_segmentbooleantrueDo not collapse curves to single points if they are shorter than the given length. The collapsing behavior exists for compatibility reasons.
ReverseCurve Change the direction of curves by swapping their start and end data

Reverse Curve · GeometryNodeReverseCurve · link

ReverseCurve(curve: Geometry, selection: Bool = true) -> (curve: Geometry)
ReverseString Reverse the order of the characters in a string

Reverse String · FunctionNodeReverseString · link

ReverseString(string: String = "") -> (string: String)
RotateEuler Apply a secondary Euler rotation to a given Euler rotation

Rotate Euler · FunctionNodeRotateEuler · link

RotateEuler(
  rotation: Vector = (0.0, 0.0, 0.0),
  rotate_by: Vector = (0.0, 0.0, 0.0),
  rotation_type: EULER,
  space: OBJECT
) -> (rotation: Vector)
SettingValuesDefault
rotation_typeAXIS_ANGLE, EULEREULERMethod used to describe the rotation
spaceOBJECT, LOCALOBJECTBase orientation for rotation
RotateInstances Rotate geometry instances in local or global space

Rotate Instances · GeometryNodeRotateInstances · link

RotateInstances(
  instances: Geometry,
  selection: Bool = true,
  rotation: Rotation = (0.0, 0.0, 0.0),
  pivot_point: Vector = (0.0, 0.0, 0.0),
  local_space: Bool = true
) -> (instances: Geometry)
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)
SDFGridBoolean Cut, subtract, or join multiple SDF volume grid inputs

SDF Grid Boolean · GeometryNodeSDFGridBoolean · link

SDFGridBoolean(grid_1: Float = 0.0, grid_2: Float = 0.0, operation: DIFFERENCE) -> (grid: Float)
SettingValuesDefault
operationINTERSECT, UNION, DIFFERENCEDIFFERENCE
SDFGridFillet Round off concave internal corners in a signed distance field. Only affects areas with negative principal curvature, creating smoother transitions between surfaces

SDF Grid Fillet · GeometryNodeSDFGridFillet · link

SDFGridFillet(grid: Float = 0.0, iterations: Int = 1) -> (grid: Float)
SDFGridLaplacian Apply Laplacian flow smoothing to a signed distance field. Computationally efficient alternative to mean curvature flow, ideal when combined with SDF normalization

SDF Grid Laplacian · GeometryNodeSDFGridLaplacian · link

SDFGridLaplacian(grid: Float = 0.0, iterations: Int = 1) -> (grid: Float)
SDFGridMean Apply mean (box) filter smoothing to a signed distance field. Fast separable averaging filter for general smoothing of the distance field

SDF Grid Mean · GeometryNodeSDFGridMean · link

SDFGridMean(grid: Float = 0.0, width: Int = 1, iterations: Int = 1) -> (grid: Float)
SDFGridMeanCurvature Apply mean curvature flow smoothing to a signed distance field. Evolves the surface based on its mean curvature, naturally smoothing high-curvature regions more than flat areas

SDF Grid Mean Curvature · GeometryNodeSDFGridMeanCurvature · link

SDFGridMeanCurvature(grid: Float = 0.0, iterations: Int = 1) -> (grid: Float)
SDFGridMedian Apply median filter to a signed distance field. Reduces noise while preserving sharp features and edges in the distance field

SDF Grid Median · GeometryNodeSDFGridMedian · link

SDFGridMedian(grid: Float = 0.0, width: Int = 1, iterations: Int = 1) -> (grid: Float)
SDFGridOffset Offset a signed distance field surface by a world-space distance. Dilates (positive) or erodes (negative) while maintaining the signed distance property

SDF Grid Offset · GeometryNodeSDFGridOffset · link

SDFGridOffset(grid: Float = 0.0, distance: Float = 0.1) -> (grid: Float)
SampleCurve Retrieve data from a point on a curve at a certain distance from its start

Sample Curve · GeometryNodeSampleCurve · link

SampleCurve(
  curves: Geometry,
  value: Float = 0.0,
  factor: Float = 0.0,
  curve_index: Int = 0,
  mode: FACTOR,
  use_all_curves: false,
  data_type: FLOAT
) -> (value: Float, position: Vector, tangent: Vector, normal: Vector)
SettingValuesDefault
modeFACTOR, LENGTHFACTORMethod for sampling input
use_all_curvesbooleanfalseSample lengths based on the total length of all curves, rather than using a length inside each selected curve
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOAT
SampleGrid Retrieve values from the specified volume grid

Sample Grid · GeometryNodeSampleGrid · link

SampleGrid(
  grid: Float = 0.0,
  position: Vector = (0.0, 0.0, 0.0),
  interpolation: Menu = "Trilinear",
  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_VECTORFLOATNode socket data type
SampleGridIndex Retrieve volume grid values at specific voxels

Sample Grid Index · GeometryNodeSampleGridIndex · link

SampleGridIndex(
  grid: Float = 0.0,
  x: Int = 0,
  y: Int = 0,
  z: Int = 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_VECTORFLOATNode socket data type
SampleIndex Retrieve values from specific geometry elements

Sample Index · GeometryNodeSampleIndex · link

SampleIndex(
  geometry: Geometry,
  value: Float = 0.0,
  index: Int = 0,
  data_type: FLOAT,
  domain: POINT,
  clamp: false
) -> (value: Float)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOAT
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINT
clampbooleanfalseClamp the indices to the size of the attribute domain instead of outputting a default value for invalid indices
SampleNearest Find the element of a geometry closest to a position. Similar to the "Index of Nearest" node

Sample Nearest · GeometryNodeSampleNearest · link

SampleNearest(
  geometry: Geometry,
  sample_position: Vector = (0.0, 0.0, 0.0),
  domain: POINT
) -> (index: Int)
SettingValuesDefault
domainPOINT, EDGE, FACE, CORNERPOINT
SampleNearestSurface Calculate the interpolated value of a mesh attribute on the closest point of its surface

Sample Nearest Surface · GeometryNodeSampleNearestSurface · link

SampleNearestSurface(
  mesh: Geometry,
  value: Float = 0.0,
  group_id: Int = 0,
  sample_position: Vector = (0.0, 0.0, 0.0),
  sample_group_id: Int = 0,
  data_type: FLOAT
) -> (value: Float, is_valid: Bool)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOAT
SampleSoundFrequencies Retrieve the amplitude from a sound data-block of a frequency range at a given time

Sample Sound Frequencies · GeometryNodeSampleSoundFrequencies · link

SampleSoundFrequencies(
  sound: Sound,
  time: Float = 0.0,
  all_channels: Bool = true,
  channel: Int = 0,
  low: Float = 0.0,
  high: Float = 10000.0,
  fft_size: Menu = 4096,
  window_function: Menu = "Hann"
) -> (amplitude: Float)
SampleUVSurface Calculate the interpolated values of a mesh attribute at a UV coordinate

Sample UV Surface · GeometryNodeSampleUVSurface · link

SampleUVSurface(
  mesh: Geometry,
  value: Float = 0.0,
  uv_map: Vector = (0.0, 0.0, 0.0),
  sample_uv: Vector = (0.0, 0.0, 0.0),
  data_type: FLOAT
) -> (value: Float, is_valid: Bool)
SettingValuesDefault
data_typeFLOAT, INT, BOOLEAN, FLOAT_VECTOR, FLOAT_COLOR, QUATERNION, FLOAT4X4, STRING, INT8, INT16_2D, INT32_2D, FLOAT2, FLOAT4, BYTE_COLORFLOAT
ScaleElements Scale groups of connected edges and faces

Scale Elements · GeometryNodeScaleElements · link

ScaleElements(
  geometry: Geometry,
  selection: Bool = true,
  scale: Float = 1.0,
  center: Vector = (0.0, 0.0, 0.0),
  scale_mode: Menu = "Uniform",
  axis: Vector = (1.0, 0.0, 0.0),
  domain: FACE
) -> (geometry: Geometry)
SettingValuesDefault
domainFACE, EDGEFACEElement type to transform
ScaleInstances Scale geometry instances in local or global space

Scale Instances · GeometryNodeScaleInstances · link

ScaleInstances(
  instances: Geometry,
  selection: Bool = true,
  scale: Vector = (1.0, 1.0, 1.0),
  center: Vector = (0.0, 0.0, 0.0),
  local_space: Bool = true
) -> (instances: Geometry)
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)
Selection User selection of the edited geometry, for tool execution

Selection · GeometryNodeToolSelection · link

Selection() -> (boolean: Bool, float: Float)
SelfObject Retrieve the object that contains the geometry nodes modifier currently being executed

Self Object · GeometryNodeSelfObject · link

SelfObject() -> (self_object: Object)
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 separate channels, based on a particular color model

Separate Color · FunctionNodeSeparateColor · link

SeparateColor(color: Color = (1.0, 1.0, 1.0, 1.0), mode: RGB) -> (red: Float, green: Float, blue: Float, alpha: Float)
SettingValuesDefault
modeRGB, HSV, HSLRGBMode of color processing
SeparateComponents Split a geometry into a separate output for each type of data in the geometry

Separate Components · GeometryNodeSeparateComponents · link

SeparateComponents(geometry: Geometry) -> (mesh: Geometry, curve: Geometry, grease_pencil: Geometry, point_cloud: Geometry, volume: Geometry, instances: Geometry)
SeparateGeometry Split a geometry into two geometry outputs based on a selection

Separate Geometry · GeometryNodeSeparateGeometry · link

SeparateGeometry(geometry: Geometry, selection: Bool = true, domain: POINT) -> (selection: Geometry, inverted: Geometry)
SettingValuesDefault
domainPOINT, EDGE, FACE, CURVE, INSTANCE, LAYERPOINTWhich domain to separate on
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)
SetCurveNormal Set the evaluation mode for curve normals

Set Curve Normal · GeometryNodeSetCurveNormal · link

SetCurveNormal(
  curve: Geometry,
  selection: Bool = true,
  mode: Menu = "Minimum Twist",
  normal: Vector = (0.0, 0.0, 1.0)
) -> (curve: Geometry)
SetCurveRadius Set the radius of the curve at each control point

Set Curve Radius · GeometryNodeSetCurveRadius · link

SetCurveRadius(curve: Geometry, selection: Bool = true, radius: Float = 0.005) -> (curve: Geometry)
SetCurveTilt Set the tilt angle at each curve control point

Set Curve Tilt · GeometryNodeSetCurveTilt · link

SetCurveTilt(curve: Geometry, selection: Bool = true, tilt: Float = 0.0) -> (curve: Geometry)
SetFaceSet Set sculpt face set values for faces

Set Face Set · GeometryNodeToolSetFaceSet · link

SetFaceSet(mesh: Geometry, selection: Bool = true, face_set: Int = 0) -> (mesh: Geometry)
SetGeometryBundle Set the bundle of a geometry

Set Geometry Bundle · GeometryNodeSetGeometryBundle · link

SetGeometryBundle(geometry: Geometry, bundle: Bundle) -> (geometry: Geometry)
SetGeometryName Set the name of a geometry for easier debugging

Set Geometry Name · GeometryNodeSetGeometryName · link

SetGeometryName(geometry: Geometry, name: String = "") -> (geometry: Geometry)
SetGreasePencilColor Set color and opacity attributes on Grease Pencil geometry

Set Grease Pencil Color · GeometryNodeSetGreasePencilColor · link

SetGreasePencilColor(
  grease_pencil: Geometry,
  selection: Bool = true,
  mode: Menu = "Stroke",
  color: Color = (1.0, 1.0, 1.0, 1.0),
  opacity: Float = 1.0,
  mode: STROKE
) -> (grease_pencil: Geometry)
SettingValuesDefault
modeSTROKE, FILL, BOTHSTROKESet the color and opacity for strokes or fills
SetGreasePencilDepth Set the Grease Pencil depth order to use

Set Grease Pencil Depth · GeometryNodeSetGreasePencilDepth · link

SetGreasePencilDepth(
  grease_pencil: Geometry,
  depth_order: Menu = "2D Layers",
  depth_order: 2D
) -> (grease_pencil: Geometry)
SettingValuesDefault
depth_order2D, 3D2D
SetGreasePencilSoftness Set softness attribute on Grease Pencil geometry

Set Grease Pencil Softness · GeometryNodeSetGreasePencilSoftness · link

SetGreasePencilSoftness(
  grease_pencil: Geometry,
  selection: Bool = true,
  softness: Float = 0.0
) -> (grease_pencil: Geometry)
SetGridBackground Set the background value used for inactive voxels and tiles

Set Grid Background · GeometryNodeSetGridBackground · link

SetGridBackground(
  grid: Float = 0.0,
  background: Float = 0.0,
  update_inactive: Bool = false,
  data_type: FLOAT
) -> (grid: 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_VECTORFLOATNode socket data type
SetGridTransform Set the transform for the grid from index space into object space.

Set Grid Transform · GeometryNodeSetGridTransform · link

SetGridTransform(grid: Float = 0.0, transform: Matrix, data_type: FLOAT) -> (is_valid: Bool, grid: 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_VECTORFLOATNode socket data type
SetHandlePositions Set the positions for the handles of Bézier curves

Set Handle Positions · GeometryNodeSetCurveHandlePositions · link

SetHandlePositions(
  curve: Geometry,
  selection: Bool = true,
  position: Vector = (0.0, 0.0, 0.0),
  offset: Vector = (0.0, 0.0, 0.0),
  mode: LEFT
) -> (curve: Geometry)
SettingValuesDefault
modeLEFT, RIGHTLEFTWhether to update left and right handles
SetHandleType Set the handle type for the control points of a Bézier curve

Set Handle Type · GeometryNodeCurveSetHandles · link

SetHandleType(curve: Geometry, selection: Bool = true, handle_type: AUTO) -> (curve: Geometry)
SettingValuesDefault
handle_typeFREE, AUTO, VECTOR, ALIGNAUTO
SetID Set the id attribute on the input geometry, mainly used internally for randomizing

Set ID · GeometryNodeSetID · link

SetID(geometry: Geometry, selection: Bool = true, id: Int = 0) -> (geometry: Geometry)
SetInstanceTransform Set the transformation matrix of every instance

Set Instance Transform · GeometryNodeSetInstanceTransform · link

SetInstanceTransform(instances: Geometry, selection: Bool = true, transform: Matrix) -> (instances: Geometry)
SetMaterial Assign a material to geometry elements

Set Material · GeometryNodeSetMaterial · link

SetMaterial(geometry: Geometry, selection: Bool = true, material: Material) -> (geometry: Geometry)
SetMaterialIndex Set the material index for each selected geometry element

Set Material Index · GeometryNodeSetMaterialIndex · link

SetMaterialIndex(geometry: Geometry, selection: Bool = true, material_index: Int = 0) -> (geometry: Geometry)
SetMeshNormal Store a normal vector for each mesh element

Set Mesh Normal · GeometryNodeSetMeshNormal · link

SetMeshNormal(
  mesh: Geometry,
  remove_custom: Bool = true,
  edge_sharpness: Bool = false,
  face_sharpness: Bool = false,
  mode: SHARPNESS,
  domain: POINT
) -> (mesh: Geometry)
SettingValuesDefault
modeSHARPNESS, FREE, TANGENT_SPACESHARPNESSStorage mode for custom normal data
domainPOINT, FACE, CORNERPOINTAttribute domain to store free custom normals
SetNURBSOrder Control how many curve control points influence each evaluated point by changing the "nurbs_order" attribute

Set NURBS Order · GeometryNodeSetNURBSOrder · link

SetNURBSOrder(curves: Geometry, selection: Bool = true, order: Int = 4) -> (curves: Geometry)
SetNURBSWeight Control the influence of each NURBS control point on the curve by changing the "nurbs_weight" attribute

Set NURBS Weight · GeometryNodeSetNURBSWeight · link

SetNURBSWeight(curves: Geometry, selection: Bool = true, weight: Float = 1.0) -> (curves: Geometry)
SetPointCloudType Change the type of point cloud

Set Point Cloud Type · GeometryNodePointsSetType · link

SetPointCloudType(points: Geometry, type: Menu = "Points") -> (points: Geometry)
SetPointRadius Set the display size of point cloud points

Set Point Radius · GeometryNodeSetPointRadius · link

SetPointRadius(points: Geometry, selection: Bool = true, radius: Float = 0.05) -> (points: Geometry)
SetPosition Set the location of each point

Set Position · GeometryNodeSetPosition · link

SetPosition(
  geometry: Geometry,
  selection: Bool = true,
  position: Vector = (0.0, 0.0, 0.0),
  offset: Vector = (0.0, 0.0, 0.0)
) -> (geometry: Geometry)
SetSelection Set selection of the edited geometry, for tool execution

Set Selection · GeometryNodeToolSetSelection · link

SetSelection(
  geometry: Geometry,
  selection: Bool = true,
  domain: POINT,
  selection_type: BOOLEAN
) -> (geometry: Geometry)
SettingValuesDefault
domainPOINT, EDGE, FACE, CURVEPOINT
selection_typeBOOLEAN, FLOATBOOLEAN
SetShadeSmooth Control the smoothness of mesh normals around each face by changing the "shade smooth" attribute

Set Shade Smooth · GeometryNodeSetShadeSmooth · link

SetShadeSmooth(
  mesh: Geometry,
  selection: Bool = true,
  shade_smooth: Bool = true,
  domain: FACE
) -> (mesh: Geometry)
SettingValuesDefault
domainEDGE, FACEFACE
SetSplineCyclic Control whether each spline loops back on itself by changing the "cyclic" attribute

Set Spline Cyclic · GeometryNodeSetSplineCyclic · link

SetSplineCyclic(curve: Geometry, selection: Bool = true, cyclic: Bool = false) -> (curve: Geometry)
SetSplineResolution Control how many evaluated points should be generated on every curve segment

Set Spline Resolution · GeometryNodeSetSplineResolution · link

SetSplineResolution(curve: Geometry, selection: Bool = true, resolution: Int = 12) -> (curve: Geometry)
SetSplineType Change the type of curves

Set Spline Type · GeometryNodeCurveSplineType · link

SetSplineType(curve: Geometry, selection: Bool = true, spline_type: POLY) -> (curve: Geometry)
SettingValuesDefault
spline_typeCATMULL_ROM, POLY, BEZIER, NURBSPOLYThe curve type to change the selected curves to
SetStringCase Convert the case of a string

Set String Case · FunctionNodeSetStringCase · link

SetStringCase(string: String = "", case: Menu = "Uppercase") -> (string: String)
ShortestEdgePaths Find the shortest paths along mesh edges to selected end vertices, with customizable cost per edge

Shortest Edge Paths · GeometryNodeInputShortestEdgePaths · link

ShortestEdgePaths(end_vertex: Bool = false, edge_cost: Float = 1.0) -> (next_vertex_index: Int, total_cost: Float)
SliceString Extract a string segment from a larger string

Slice String · FunctionNodeSliceString · link

SliceString(string: String = "", position: Int = 0, length: Int = 10) -> (string: String)
SortElements Rearrange geometry elements, changing their indices

Sort Elements · GeometryNodeSortElements · link

SortElements(
  geometry: Geometry,
  selection: Bool = true,
  group_id: Int = 0,
  sort_weight: Float = 0.0,
  domain: POINT
) -> (geometry: Geometry)
SettingValuesDefault
domainPOINT, EDGE, FACE, CURVE, INSTANCEPOINT
SortList Sort a list based on weights

Sort List · GeometryNodeSortList · link

SortList(
  list: Float = 0.0,
  selection: Bool = true,
  group_id: Int = 0,
  sort_weight: Float = 0.0,
  socket_type: FLOAT
) -> (list: Float)
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
SpecialCharacters Output string characters that cannot be typed directly with the keyboard

Special Characters · FunctionNodeInputSpecialCharacters · link

SpecialCharacters() -> (line_break: String, tab: String)
Spiral Generate a poly spline in a spiral shape

Spiral · GeometryNodeCurveSpiral · link

Spiral(
  resolution: Int = 32,
  rotations: Float = 2.0,
  start_radius: Float = 1.0,
  end_radius: Float = 2.0,
  height: Float = 2.0,
  reverse: Bool = false
) -> (curve: Geometry)
SplineLength Retrieve the total length of each spline, as a distance or as a number of points

Spline Length · GeometryNodeSplineLength · link

SplineLength() -> (length: Float, point_count: Int)
SplineParameter Retrieve how far along each spline a control point is

Spline Parameter · GeometryNodeSplineParameter · link

SplineParameter() -> (factor: Float, length: Float, index: Int)
SplineResolution Retrieve the number of evaluated points that will be generated for every control point on curves

Spline Resolution · GeometryNodeInputSplineResolution · link

SplineResolution() -> (resolution: Int)
SplitEdges Duplicate mesh edges and break connections with the surrounding faces

Split Edges · GeometryNodeSplitEdges · link

SplitEdges(mesh: Geometry, selection: Bool = true) -> (mesh: Geometry)
SplitString Split a string into a list using a separator

Split String · FunctionNodeSplitString · link

SplitString(string: String = "", separator: String = "") -> (list: String)
SplitToInstances Create separate geometries containing the elements from the same group

Split to Instances · GeometryNodeSplitToInstances · link

SplitToInstances(
  geometry: Geometry,
  selection: Bool = true,
  group_id: Int = 0,
  domain: POINT
) -> (instances: Geometry, group_id: Int)
SettingValuesDefault
domainPOINT, EDGE, FACE, CURVE, INSTANCE, LAYERPOINTAttribute domain for the Selection and Group ID inputs
Star Generate a poly spline in a star pattern by connecting alternating points of two circles

Star · GeometryNodeCurveStar · link

Star(
  points: Int = 8,
  inner_radius: Float = 1.0,
  outer_radius: Float = 2.0,
  twist: Float = 0.0
) -> (curve: Geometry, outer_points: Bool)
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
StoreNamedAttribute Store the result of a field on a geometry as an attribute with the specified name

Store Named Attribute · GeometryNodeStoreNamedAttribute · link

StoreNamedAttribute(
  geometry: Geometry,
  selection: Bool = true,
  name: String = "",
  value: Float = 0.0,
  data_type: FLOAT,
  domain: POINT
) -> (geometry: Geometry)
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
domainPOINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERPOINTWhich domain to store the data in
StoreNamedGrid Store grid data in a volume geometry with the specified name

Store Named Grid · GeometryNodeStoreNamedGrid · link

StoreNamedGrid(
  volume: Geometry,
  name: String = "",
  grid: Float = 0.0,
  data_type: FLOAT
) -> (volume: Geometry)
SettingValuesDefault
data_typeBOOLEAN, FLOAT, DOUBLE, INT, INT64, MASK, VECTOR_FLOAT, VECTOR_DOUBLE, VECTOR_INT, POINTS, UNKNOWNFLOATType of grid data
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)
StringToCurves Generate a paragraph of text with a specific font, using a curve instance to store each character

String to Curves · GeometryNodeStringToCurves · link

StringToCurves(
  string: String = "",
  size: Float = 1.0,
  font: Font = "Bfont Regular",
  align_x: Menu = "Left",
  align_y: Menu = "Top Baseline",
  pivot_point: Menu = "Midpoint",
  character_spacing: Float = 1.0,
  word_spacing: Float = 1.0,
  line_spacing: Float = 1.0,
  overflow: Menu = "Overflow",
  text_box_width: Float = 0.0,
  text_box_height: Float = 0.0
) -> (curve_instances: Geometry, remainder: String, line: Int, word: Int, pivot_point: Vector)
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
SubdivideCurve Dividing each curve segment into a specified number of pieces

Subdivide Curve · GeometryNodeSubdivideCurve · link

SubdivideCurve(curve: Geometry, cuts: Int = 1) -> (curve: Geometry)
SubdivideMesh Divide mesh faces into smaller ones without changing the shape or volume, using linear interpolation to place the new vertices

Subdivide Mesh · GeometryNodeSubdivideMesh · link

SubdivideMesh(mesh: Geometry, level: Int = 1) -> (mesh: Geometry)
SubdivisionSurface Divide mesh faces to form a smooth surface, using the Catmull-Clark subdivision method

Subdivision Surface · GeometryNodeSubdivisionSurface · link

SubdivisionSurface(
  mesh: Geometry,
  level: Int = 1,
  edge_crease: Float = 0.0,
  vertex_crease: Float = 0.0,
  limit_surface: Bool = true,
  quality: Int = 3,
  uv_smooth: Menu = "Keep Boundaries",
  boundary_smooth: Menu = "All"
) -> (mesh: Geometry)
Switch Switch between two inputs

Switch · GeometryNodeSwitch · link

Switch(
  switch: Bool = false,
  false_: Float = 0.0,
  true_: Float = 0.0,
  input_type: FLOAT
) -> (output: Float)
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_VECTORFLOAT
TagFilter Check if a filter string matches a list of tags

Tag Filter · GeometryNodeTagFilter · link

TagFilter(tag_filter: String = "", tags: String = "") -> (match: Bool)
Tool3DCursor The scene's 3D cursor location and rotation

3D Cursor · GeometryNodeTool3DCursor · link

Tool3DCursor() -> (location: Vector, rotation: Rotation)
TransferAttributes Copy attributes from one geometry to another

Transfer Attributes · GeometryNodeTransferAttributes · link

TransferAttributes(
  target: Geometry,
  target_point_id: Int = 0,
  target_edge_id: Int = 0,
  target_face_id: Int = 0,
  target_corner_id: Int = 0,
  target_curve_id: Int = 0,
  target_instance_id: Int = 0,
  source: Geometry,
  source_point_id: Int = 0,
  source_edge_id: Int = 0,
  source_face_id: Int = 0,
  source_corner_id: Int = 0,
  source_curve_id: Int = 0,
  source_instance_id: Int = 0,
  pattern_mode: Menu = "Wildcard",
  attribute_names: String = "",
  exclude_names: Bool = false
) -> (target: Geometry, transferred_names: String)
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)
TransformGeometry Translate, rotate or scale the geometry

Transform Geometry · GeometryNodeTransform · link

TransformGeometry(
  geometry: Geometry,
  mode: Menu = "Components",
  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
) -> (geometry: Geometry)
TransformGizmo Show a transform gizmo in the viewport

Transform Gizmo · GeometryNodeGizmoTransform · link

TransformGizmo(
  value: Matrix,
  position: Vector = (0.0, 0.0, 0.0),
  rotation: Rotation = (0.0, 0.0, 0.0),
  use_translation_x: true,
  use_translation_y: true,
  use_translation_z: true,
  use_rotation_x: true,
  use_rotation_y: true,
  use_rotation_z: true,
  use_scale_x: true,
  use_scale_y: true,
  use_scale_z: true
) -> (transform: Geometry)
SettingValuesDefault
use_translation_xbooleantrue
use_translation_ybooleantrue
use_translation_zbooleantrue
use_rotation_xbooleantrue
use_rotation_ybooleantrue
use_rotation_zbooleantrue
use_scale_xbooleantrue
use_scale_ybooleantrue
use_scale_zbooleantrue
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)
TranslateInstances Move top-level geometry instances in local or global space

Translate Instances · GeometryNodeTranslateInstances · link

TranslateInstances(
  instances: Geometry,
  selection: Bool = true,
  translation: Vector = (0.0, 0.0, 0.0),
  local_space: Bool = true
) -> (instances: Geometry)
TransposeMatrix Flip a matrix over its diagonal, turning columns into rows and vice-versa

Transpose Matrix · FunctionNodeTransposeMatrix · link

TransposeMatrix(matrix: Matrix) -> (matrix: Matrix)
Triangulate Convert all faces in a mesh to triangular faces

Triangulate · GeometryNodeTriangulate · link

Triangulate(
  mesh: Geometry,
  selection: Bool = true,
  quad_method: Menu = "Shortest Diagonal",
  n_gon_method: Menu = "Beauty"
) -> (mesh: Geometry)
TrimCurve Shorten curves by removing portions at the start or end

Trim Curve · GeometryNodeTrimCurve · link

TrimCurve(
  curve: Geometry,
  selection: Bool = true,
  start: Float = 0.0,
  end: Float = 1.0,
  mode: FACTOR
) -> (curve: Geometry)
SettingValuesDefault
modeFACTOR, LENGTHFACTORHow to find endpoint positions for the trimmed spline
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)
UVSphere Generate a spherical mesh with quads, except for triangles at the top and bottom

UV Sphere · GeometryNodeMeshUVSphere · link

UVSphere(segments: Int = 32, rings: Int = 16, radius: Float = 1.0) -> (mesh: Geometry, uv_map: Vector)
UVTangent Generate tangent directions based on a UV map

UV Tangent · GeometryNodeUVTangent · link

UVTangent(method: Menu = "Exact", uv: Vector = (0.0, 0.0)) -> (tangent: Vector)
UVUnwrap Generate a UV map based on seam edges

UV Unwrap · GeometryNodeUVUnwrap · link

UVUnwrap(
  selection: Bool = true,
  seam: Bool = false,
  margin: Float = 0.001,
  fill_holes: Bool = true,
  method: Menu = "Angle Based",
  iterations: Int = 10,
  no_flip: Bool = false
) -> (uv: Vector)
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)

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
VertexNeighbors Retrieve topology information relating to each vertex of a mesh

Vertex Neighbors · GeometryNodeInputMeshVertexNeighbors · link

VertexNeighbors() -> (vertex_count: Int, face_count: Int)
VertexOfCorner Retrieve the vertex each face corner is attached to

Vertex of Corner · GeometryNodeVertexOfCorner · link

VertexOfCorner(corner_index: Int = 0) -> (vertex_index: Int)
Viewer Display the input data in the Spreadsheet Editor

Viewer · GeometryNodeViewer · link

Viewer(ui_shortcut: 0, domain: AUTO)
SettingValuesDefault
ui_shortcutint0
domainAUTO, POINT, EDGE, FACE, CORNER, CURVE, INSTANCE, LAYERAUTODomain to evaluate fields on
ViewportTransform Retrieve the view direction and location of the 3D viewport

Viewport Transform · GeometryNodeViewportTransform · link

ViewportTransform() -> (projection: Matrix, view: Matrix, is_orthographic: Bool)
VolumeCube Generate a dense volume with a field that controls the density at each grid voxel based on its position

Volume Cube · GeometryNodeVolumeCube · link

VolumeCube(
  density: Float = 1.0,
  background: Float = 0.0,
  min: Vector = (-1.0, -1.0, -1.0),
  max: Vector = (1.0, 1.0, 1.0),
  resolution_x: Int = 32,
  resolution_y: Int = 32,
  resolution_z: Int = 32
) -> (volume: Geometry)
VolumeToMesh Generate a mesh on the "surface" of a volume

Volume to Mesh · GeometryNodeVolumeToMesh · link

VolumeToMesh(
  volume: Geometry,
  resolution_mode: Menu = "Grid",
  voxel_size: Float = 0.3,
  voxel_amount: Float = 64.0,
  threshold: Float = 0.1,
  adaptivity: Float = 0.0
) -> (mesh: Geometry)
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
VoxelIndex Retrieve the integer coordinates of the voxel that the field is evaluated on

Voxel Index · GeometryNodeInputVoxelIndex · link

VoxelIndex() -> (x: Int, y: Int, z: Int, is_tile: Bool, extent_x: Int, extent_y: Int, extent_z: Int)
VoxelizeGrid Remove sparseness from a volume grid by making the active tiles into voxels

Voxelize Grid · GeometryNodeGridVoxelize · link

VoxelizeGrid(grid: Float = 0.0, data_type: FLOAT) -> (grid: 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_VECTORFLOATNode socket data type
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: 3D) -> (value: Float, color: Color)
SettingValuesDefault
noise_dimensions1D, 2D, 3D, 4D3DNumber of dimensions to output noise for
XPBDSolver Simulate physics using the XPBD framework

XPBD Solver · GeometryNodeXPBDSolver · link

XPBDSolver(
  world: Bundle,
  delta_time: Float = 0.04,
  filter: String = "",
  simulation_to_world: Matrix,
  substeps: Int = 10,
  constraint_iterations: Int = 1,
  solver_path: String = "",
  begin: Float = 0.0,
  end: Float = 1.0
) -> (world: Bundle)