Vector geometry — splines, shapes, and path operations. Most outputs here are `spline` values that downstream nodes can resample, stroke, or sample along.
Generators
Accretive Growth
accretive-growthpolymorphic
Grow a branching structure that accumulates over time — elements attach to what's already there and never move again, so Progress just reveals the growth (scrub it either way, it's free). Space Colonization scatters attractor points and lets branches race toward them, consuming each as it's reached (influence radius = how far a branch can 'see', kill distance = how close it must get) — trees, veins, river deltas, coral. DLA fires random walkers at the cluster and sticks them where they touch: frost and lichen, with Stickiness below 1 packing it denser and Drift blowing it sideways; seed from the Region edge for frost creeping off a shape. Percolation eats across a grid — Invasion follows the wired Resistance image, burrowing through dark areas and stalling at light ones, while Eden spreads uniformly into compact rough blobs. Laplacian solves the electric field around the growing shape and grows where it's strongest, so one slider (Eta) morphs the whole family: 0 is a compact blob, 1 is DLA-like coral, and high values leave only the most exposed tips growing — lightning. Wire an Attractor mask to steer the discharge toward a target. It is the expensive mode; Grid and Max elements drive its cost. Crack and Hyphal grow networks rather than trees — tips propagate, branch, and stop dead when they touch existing growth, recording the join: Crack nucleates at scattered origins that each spread both ways and T into each other (mud cracks, craquelure, shattered glass), while Hyphal radiates from a single seed and fuses where strands meet (mycelium, neurites). Space Colonization's Venation can also be set to closed, so converging branches fuse into the loops real leaf veins have instead of staying a strict tree. Region (mask or spline) confines any of them: scatter into a text silhouette and growth fills the letters. Branch thickness follows Da Vinci's rule and rides the anchor width channel; age rides the subpath driver channel, so Stroke's driver ramps colour by how old each branch is. Emit as Limbs (one continuous path per branch — the cheap default), Branches (overlapping root-to-tip paths for Trim Path; costly on big trees), Segments (one subpath per edge) or Boundary (the silhouette of the grown mass, for filling).
Generate a circular arc / pie wedge as a spline — set radius, start/end angle, and whether it's an open arc, a pie, or a chord.
Parameters
Name
Type
Default
Center X
centerX
scalar
0 … 1
0.5
Center Y
centerY
scalar
0 … 1
0.5
Radius
radius
scalar
0 … 1
0.3
Start angle (°)
startAngle
scalar
-360 … 360
0
End angle (°)
endAngle
scalar
-360 … 360
270
Mode
mode
enum
"open"
open · pie · chord
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
Arrow
arrowpolymorphic
Generate an arrow outline as a closed spline — aim it tail→tip and set the shaft thickness and head size.
Parameters
Name
Type
Default
Tail X
tailX
scalar
0 … 1
0.25
Tail Y
tailY
scalar
0 … 1
0.5
Tip X
tipX
scalar
0 … 1
0.75
Tip Y
tipY
scalar
0 … 1
0.5
Shaft thickness
shaftThickness
scalar
0 … 0.5
0.04
Head length
headLength
scalar
0 … 1
0.12
Head width
headWidth
scalar
0 … 1
0.12
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
Circle
circlepolymorphic
Generate a circle (or ellipse, via non-uniform radii) as a closed spline.
Parameters
Name
Type
Default
Center X
centerX
scalar
0 … 1
0.5
Center Y
centerY
scalar
0 … 1
0.5
Radius X
radiusX
scalar
0 … 1
0.25
Radius Y
radiusY
scalar
0 … 1
0.25
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
Connect Points
connect-points
Connect pairs of input points within a max-distance threshold. Path modes shape each connection: straight chords, circular arcs / S-curves (curved), hanging-wire droop (sag), noise-field tangents (flow), smooth curves flowing through shared points (network), parallel connections merging into trunks (bundle), or bowing toward/away from a center (attract). `Min connections` prunes the sparse fringe: an edge survives only when BOTH its endpoints found at least that many neighbours inside the threshold, so stringy one-off segments drop out and the dense core stays. Primary output is the segments as a spline; the passthrough `points` aux keeps the original points available on the same wire for further downstream use.
Generate a crosshair / registration mark — four arms with an adjustable central gap (start offset), arm length, and rotation.
Parameters
Name
Type
Default
Center X
centerX
scalar
0 … 1
0.5
Center Y
centerY
scalar
0 … 1
0.5
Arm length
length
scalar
0 … 1
0.15
Start offset (gap)
startOffset
scalar
0 … 1
0
Rotation (°)
rotation
scalar
-180 … 180
0
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
L-System
l-system
Grow botanical and fractal structures from a rewriting grammar — a short rule set expanded a few times and drawn by a turtle. Pick a preset (fern, bush, plant, tree, Koch, Hilbert, dragon, Sierpinski) and shape it with Angle, Length and Length decay, or switch to Custom and write your own productions: one per line as `F=F[+F]F[-F]F`, with `F`/`G` drawing, `f`/`g` moving without drawing, `+`/`-` turning, and `[`/`]` saving and restoring the turtle. Rules can be stochastic — `A=0.7:F[+A] | 0.3:F[-A]` — which, with Angle jitter and Tropism (a global bend, for gravity or light), is what stops L-system plants looking like clip art. Two separate animation inputs: Progress reveals the finished structure outward level by level, while Iterations is fractional and morphs between structural levels, extending the newest tips out of their parents. Branch thickness follows Da Vinci's rule on the anchor width channel and age rides the subpath driver channel, so Stroke ramps can colour by either.
Parameters
Name
Type
Default
Preset
preset
enum
"fern"
fern · bush · plant · tree · koch · hilbert · dragon · sierpinski · custom
Axiom
axiom
string
"X"
Rules
rules
string
"X=F+[[X]-X]-F[-FX]+X\nF=FF"
Iterations
iterations
scalar
0 … 12
5
Progress
progress
scalar
0 … 1
1
Preset angle
use_preset_shape
boolean
true
Angle
angle
scalar
0 … 180
25
Angle jitter
angle_jitter
scalar
0 … 1
0
Length
length
scalar
0.0005 … 0.2
0.04
Length decay
length_decay
scalar
0.5 … 1.2
0.9
Tropism angle
tropism_angle
scalar
-180 … 180
90
Tropism
tropism_strength
scalar
0 … 1
0
Origin X
origin_x
scalar
-0.5 … 1.5
0.5
Origin Y
origin_y
scalar
-0.5 … 1.5
0.92
Start angle
start_angle
scalar
-180 … 180
-90
Seed
seed
scalar
0 … 10000
0
Max elements
max_elements
scalar
100 … 200000
20000
Emit
emit
enum
"limbs"
limbs · branches · segments
Tip width
tip_width
scalar
0 … 1
0.1
ID mode
id_mode
enum
"branch"
branch · depth · root · birth
ID groups
id_groups
scalar
2 … 32
6
Sockets
Direction
Name
Type
outputprimary
out
spline
outputaux
points
points
Lissajous 2D
lissajous-2d
Generate a 2D Lissajous curve as a spline. x(t) = Ax·sin(fx·t + φx), y(t) = Ay·sin(fy·t + φy) over t ∈ [0, 2π]. Integer frequency ratios produce closed curves. Aux `points` output carries the same samples as a points value.
Parameters
Name
Type
Default
Samples
samples
scalar
16 … 4096
256
Amplitude X
ax
scalar
0 … 1
0.4
Amplitude Y
ay
scalar
0 … 1
0.4
Frequency X
fx
scalar
0 … 64
3
Frequency Y
fy
scalar
0 … 64
2
Phase X (× π)
phase_x
scalar
-2 … 2
0.5
Phase Y (× π)
phase_y
scalar
-2 … 2
0
Rotation (rad)
rotation
scalar
-3.141592653589793 … 3.141592653589793
0
Center X
center_x
scalar
0 … 1
0.5
Center Y
center_y
scalar
0 … 1
0.5
Sockets
Direction
Name
Type
outputprimary
out
spline
outputaux
points
points
Lissajous 3D
lissajous-3d
Generate a 3D Lissajous curve, rotate it (extrinsic XYZ), and orthographically project to UV space. Three frequencies, three phases (in turns — each whole 0→1 span is one full cycle, so a keyframed phase loops seamlessly), three rotations (rad), and per-axis amplitudes give classic 3D Lissajous knots and harmonograph-style figures. Aux `points` output carries the projected samples as a points value.
Parameters
Name
Type
Default
Samples
samples
scalar
16 … 4096
512
Amplitude X
ax
scalar
0 … 1
0.3
Amplitude Y
ay
scalar
0 … 1
0.3
Amplitude Z
az
scalar
0 … 1
0.3
Frequency X
fx
scalar
0 … 64
1
Frequency Y
fy
scalar
0 … 64
3
Frequency Z
fz
scalar
0 … 64
2
Phase X (turns)
phase_x
scalar
-2 … 2
0.25
Phase Y (turns)
phase_y
scalar
-2 … 2
0
Phase Z (turns)
phase_z
scalar
-2 … 2
0
Rotation X (rad)
rx
scalar
-3.141592653589793 … 3.141592653589793
0
Rotation Y (rad)
ry
scalar
-3.141592653589793 … 3.141592653589793
0
Rotation Z (rad)
rz
scalar
-3.141592653589793 … 3.141592653589793
0
Center X
center_x
scalar
0 … 1
0.5
Center Y
center_y
scalar
0 … 1
0.5
Sockets
Direction
Name
Type
outputprimary
out
spline
outputaux
points
points
Loop Weave
loop-weave
Draw one continuous spline through a point set, loop-de-looping around each point in an elliptical orbit. Alternate-handed orbits weave (connectors cross between points); same-handed reads as cursive loops. Spiral, lobes and wobble reshape the loops; tension, swing and sag reshape the runs between them. Aux outputs carry the orbit ellipses and untraveled dashed-guide arcs. Progress reveals the path point by point; auto reveal draws each arriving point's loop with the timeline.
Parameters
Name
Type
Default
Order
order
enum
"index"
index · nearest
Radius
radius
scalar
0.005 … 1
0.06
Radius jitter
radius_jitter
scalar
0 … 1
0.35
Adaptive radius
adaptive_radius
scalar
0 … 1
0
Use point scale
use_point_scale
boolean
true
Squash
squash
scalar
0 … 0.9
0.25
Orient
orient
enum
"travel"
travel · fixed · random · point
Angle (°)
orient_angle
scalar
0 … 360
0
Spiral
spiral
scalar
-1 … 1
0
Lobes
lobes
scalar
0 … 8
0
Lobe depth
lobe_depth
scalar
0 … 1
0.25
Wobble
wobble
scalar
0 … 1
0
Loops
loops
scalar
0 … 8
1
Loops jitter
loops_jitter
scalar
0 … 1
0
Direction
direction
enum
"alternate"
alternate · cw · ccw · random
Tension
tension
scalar
0.2 … 3
1
Swing
swing
scalar
-1 … 1
0
Sag
sag
scalar
-1 … 1
0
Seed
seed
scalar
0 … 9999
0
Ends
ends
enum
"center"
center · orbit
Smoothness
smoothness
scalar
0 … 1
0.5
Progress
progress
scalar
0 … 1
1
Reveal
reveal_mode
enum
"off"
off · auto
Reveal time
reveal_time
scalar
0.05 … 5
0.6
Sockets
Direction
Name
Type
input*
points
points
points
outputprimary
out
spline
outputaux
orbits
spline
outputaux
skipped
spline
Points to Spline
points-to-spline
Chain points into a spline in index order. Each groupIndex becomes its own subpath (Copy to Points / Collect output splits naturally). Curve = linear polyline or smooth catmull-rom through every point; close wraps each subpath.
Parameters
Name
Type
Default
Curve
curve
enum
"linear"
linear · smooth
Close
closed
boolean
false
Sockets
Direction
Name
Type
input*
points
points
points
outputprimary
out
spline
Polygon
polygonpolymorphic
Generate a regular polygon as a closed spline — set the number of sides, radius, and rotation.
Parameters
Name
Type
Default
Center X
centerX
scalar
0 … 1
0.5
Center Y
centerY
scalar
0 … 1
0.5
Radius
radius
scalar
0 … 1
0.3
Sides
sides
scalar
3 … 64
5
Rotation (°)
rotation
scalar
-180 … 180
0
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
Rectangle
rectanglepolymorphic
Generate a rectangle as a closed spline, optionally with rounded corners.
Parameters
Name
Type
Default
X
originX
scalar
0 … 1
0.5
Y
originY
scalar
0 … 1
0.5
Width
width
scalar
0 … 1
0.5
Height
height
scalar
0 … 1
0.5
Corner radius
corner_radius
scalar
0 … 0.5
0
Rotate (°)
rotate
scalar
-360 … 360
0
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
Shortest Path
shortest-pathpolymorphic
Route through a network and output the path as a spline. Points mode: hops between points within the max distance, from a start position (snapped to the nearest point) to an end position or group — visited points ride the aux output. Spline mode: walks a wired network's own curved segments between two groups, or emits N seeded random routes. Tree mode: one root point (by index) fans out to every reachable point as a branching tree that never re-crosses — wander morphs direct↔minimal branching, and the update mode locks the topology at frame 0 (edges stretch as points move) or rebuilds live with an optional glide. Points and tree modes share Connect Points' path shaping (arcs / S-curves, sag, flow, network smoothing, bundling, attract). Animate the draw-on with Trim Path.
Generate a sine wave as an open spline — set amplitude, cycles, phase, and the horizontal span.
Parameters
Name
Type
Default
Center X
centerX
scalar
0 … 1
0.5
Center Y
centerY
scalar
0 … 1
0.5
Width
width
scalar
0 … 1
0.8
Amplitude
amplitude
scalar
0 … 1
0.15
Cycles
cycles
scalar
0.25 … 20
2
Phase (×π)
phase
scalar
-2 … 2
0
Points / cycle
resolution
scalar
4 … 64
16
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
Space Fill
space-fill
Fill space with packed self-avoiding walk lines — a walker steps across a pixel grid always heading as straight as it can through free cells, blocking a fat neighborhood as it goes, so lines pack tightly against each other into dense maze-like structure with long parallel runs and 45°/90° kinks. Each line is one open subpath tagged with a group id (ID Mode: per-line, seeded random, spatial cluster, draw order, or length rank) — style downstream with Rasterize Spline / Stroke ramps set to 'group', and map per-line weight with Stroke's thickness 'driver' mode. Progress reveals the drawing over time (keyframe it to watch it draw); Region and Obstacles masks confine where the walk may go. Aux `tips` emits one point per line at its current drawing tip.
Parameters
Name
Type
Default
Progress
progress
scalar
0 … 1
1
Coverage
coverage
scalar
0.05 … 1
0.85
Max lines
max_lines
scalar
1 … 2000
250
Seed
seed
scalar
0 … 10000
0
Margin
margin
scalar
0 … 0.25
0.02
Step min
step_min
scalar
1 … 8
1
Step max
step_max
scalar
1 … 8
4
Metric
metric
enum
"straight"
straight · farthest · manhattan · weighted
Wobble
wobble
scalar
0 … 1
1
Wander
wander
scalar
0 … 1
0.1
Auto spacing
spacing_auto
boolean
true
Spacing (px)
spacing
scalar
0 … 8
2
Max line steps
line_steps
scalar
16 … 20000
3000
Starts
start_mode
enum
"near-previous"
near-previous · anywhere
Start area
start_area
scalar
0.05 … 1
1
Weight min
weight_min
scalar
0 … 1
0.6
Weight max
weight_max
scalar
0 … 1
0.9
ID mode
id_mode
enum
"cluster"
cluster · random · order · size · line
ID groups
id_groups
scalar
2 … 32
6
Cluster grid
cluster_grid
scalar
2 … 16
4
ID seed
id_seed
scalar
0 … 10000
0
Sockets
Direction
Name
Type
input
Region
region
mask
input
Obstacles
obstacles
mask
outputprimary
out
spline
outputaux
tips
points
Spiral
spiralpolymorphic
Generate an Archimedean spiral as an open spline — set turns, inner/outer radius, and direction.
Parameters
Name
Type
Default
Center X
centerX
scalar
0 … 1
0.5
Center Y
centerY
scalar
0 … 1
0.5
Turns
turns
scalar
0.25 … 20
3
Inner radius
innerRadius
scalar
0 … 1
0
Outer radius
outerRadius
scalar
0 … 1
0.35
Points / turn
pointsPerTurn
scalar
4 … 64
16
Direction
direction
enum
"clockwise"
clockwise · counterclockwise
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
Spline Draw
spline-drawpolymorphic
Author a bezier path with the pen tool over the preview canvas. Outputs the spline as data and, when stroke or fill is enabled, as a rasterized image.
Parameters
Name
Type
Default
Opacity
opacity
scalar
0 … 1
1
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill (closes path)
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
Spline Trails
spline-trails
Trace each input point's motion over time as its own spline — the classic motion trail. Feed it anything animated (Points on Path with Animate, a particle sim's points, Modulate Points wiggle) and wire the output into Stroke or Rasterize Spline. Length sets how many seconds of history each trail keeps; Tail width tapers the stroke toward the oldest end (0 = fades to nothing, 1 = uniform). Trails follow point identity through membership changes, so a vanished point's trail fades out naturally. Scene-time driven: paused edits reposition trail heads without growing them, and exports reproduce the preview.
Parameters
Name
Type
Default
Length (s)
length
scalar
0.05 … 30
0.75
Curve
curve
enum
"smooth"
linear · smooth
Tail width
tail_width
scalar
0 … 1
0
Clear on loop
clear_on_loop
boolean
true
Sockets
Direction
Name
Type
input*
points
points
points
outputprimary
out
spline
Star
starpolymorphic
Generate an N-point star as a closed spline — set the point count, outer/inner radius, and rotation.
Parameters
Name
Type
Default
Center X
centerX
scalar
0 … 1
0.5
Center Y
centerY
scalar
0 … 1
0.5
Points
points
scalar
3 … 32
5
Outer radius
outerRadius
scalar
0 … 1
0.3
Inner radius
innerRadius
scalar
0 … 1
0.13
Rotation (°)
rotation
scalar
-180 … 180
0
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Stroke
stroke_enabled
boolean
true
Thickness
stroke_thickness
scalar
0 … 200
4
Units
stroke_units
enum
"px"
px · %
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
false
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
outputaux
element
element
String Art
string-art
Times-table string art: connect ordered point i to point (i·k + offset) mod N with a straight chord. Connecting i → 2i around a circle draws a cardioid, 3i a nephroid, etc. — the line envelopes are the curve. Feed evenly-spaced points (e.g. Points on Path around a circle or rectangle). Optional second layer with its own multiplier. Pairs with Spline Intersections to mark the chord crossings.
Parameters
Name
Type
Default
Multiplier k
k
scalar
2 … 200
2
Offset
offset
scalar
0 … 200
0
Second layer
layer2
boolean
false
Multiplier k₂
k2
scalar
2 … 200
5
Sockets
Direction
Name
Type
input*
points
points
points
outputprimary
out
spline
outputaux
points
points
SVG Source
svg-sourcepolymorphic
Load an SVG file and emit it as spline data. Built-in translate/scale/rotate operate on the result; stroke and fill rasterize to an image.
Parameters
Name
Type
Default
Opacity
opacity
scalar
0 … 1
1
SVG
file
svg_file
—
Stroke
stroke_enabled
boolean
false
Thickness (px)
stroke_thickness
scalar
0 … 200
2
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
true
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Translate X
translateX
scalar
-2 … 2
0
Translate Y
translateY
scalar
-2 … 2
0
Scale X
scaleX
scalar
-5 … 5
1
Scale Y
scaleY
scalar
-5 … 5
1
Rotate (deg)
rotate
scalar
-360 … 360
0
Pivot X
pivotX
scalar
0 … 1
0.5
Pivot Y
pivotY
scalar
0 … 1
0.5
Sockets
Direction
Name
Type
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
Modifiers
Blend Intersections
blend-intersections
Fuse a network of splines into one closed outline shape: thin stroke bodies that swell into webbed ink-pools wherever strokes cross or come within the Blend radius — including a stroke crossing itself. Width sets the stroke body thickness, Blend the webbing size (0 = plain union of the stroked bodies). Outputs a spline — wire into Rasterize Spline to fill it, or stroke its outline. Combine multiple splines upstream with Collect.
Parameters
Name
Type
Default
Width
width
scalar
0.5 … 200
6
Blend
blend
scalar
0 … 400
24
Units
units
enum
"px"
px · %
Resolution
resolution
scalar
64 … 768
288
Smoothing
smoothing
scalar
0 … 1
0.5
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
spline
Differential Growth
differential-growth
Grow a curve faster than the space around it can hold, so it has no choice but to buckle — brain coral, kelp, ruffled leaf margins, intestines. Every node pushes its neighbours apart while the chain pulls itself together, and any edge stretched past Split length inserts a new node, so the curve keeps lengthening in place. Closed input loops become inflating blobs (raise Pressure), open ones become tendrils. The mode sets WHERE new length appears: Uniform ruffles evenly, Curvature grows convex regions faster so bulges sharpen and sub-divide into cauliflower lobes, Field takes a wired mask so you can paint exactly where it crinkles, and Noise breaks it up patchily. Region confines the curve and Obstacles carve holes it must ruffle around. This is a live simulation, not a cached one — it evolves while the timeline plays and resets when the scene loops, so there is no Progress slider. Bend stiffness trades a smooth ruffle for a jagged one; Collapse length keeps the anchor count from running away.
Parameters
Name
Type
Default
Mode
mode
enum
"uniform"
uniform · curvature · field · noise
Split length
split_length
scalar
0.002 … 0.1
0.012
Collapse length
collapse_length
scalar
0 … 0.05
0.003
Growth rate
growth_rate
scalar
0 … 1
1
Repulsion radius
repulsion_radius
scalar
0.002 … 0.2
0.009
Repulsion
repulsion_strength
scalar
0 … 2
1
Attraction
attraction_strength
scalar
0 … 2
0.6
Bend stiffness
bend_stiffness
scalar
0 … 1
0.3
Pressure
pressure
scalar
-1 … 1
0
Damping
damping
scalar
0.01 … 1
0.5
Iterations
iterations
scalar
1 … 20
3
Curves collide
inter_curve
boolean
true
Pin ends
pin_ends
boolean
false
Containment
containment
scalar
0 … 1
1
Max anchors
max_anchors
scalar
32 … 100000
8000
Seed
seed
scalar
0 … 10000
0
Sockets
Direction
Name
Type
input*
Spline
spline
spline
input
Region
region
mask
input
Obstacles
obstacles
mask
input
Growth field
growth_field
mask
outputprimary
out
spline
outputaux
points
points
Diffusion Curves
diffusion-curves
Paint with gradients by drawing their boundaries (Orzan et al. 2008). Every subpath of the wired spline becomes a diffusion curve: the Left/Right color ramps run along the curve's length and diffuse outward from its two sides, filling the whole canvas with smooth shading while staying sharp across the curve itself. Per-stop ramp alpha diffuses too, so a drawing can fade to transparent for Merge compositing. Wire an image into `Trace` (color source: image) to sample its colors along your strokes instead — a few curves over a photo reconstruct a painterly version, live when the trace input animates. Blur softens the transition across the curve, shaped along its length by the blur curve. Crossing curves compete and blend — split curves or add stops to control junctions. Quality raises solver iterations; Resolution trades edge sharpness for speed on animated curves.
Fill the interior of a spline. Open subpaths close implicitly for rendering. Choose evenodd (SVG default, punches holes in nested subpaths) or nonzero winding rule.
Parameters
Name
Type
Default
Color
color
color
"#ffffff"
Stack subpaths
stack_subpaths
boolean
true
Fill rule
rule
enum
"evenodd"
evenodd · nonzero
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
image
Filter Splines
filter-splines
Keep or discard whole subpaths of a spline by predicate — the spline sibling of Filter Points. Bbox tests each subpath's bounds against an XY window (by center, fully inside, or overlapping); Mask keeps subpaths where the wired image's luminance is ≥ threshold, sampled at the center or averaged along the path; Size keeps subpaths whose length or area falls in a range (raise Min to cull speck fragments after a boolean or trace); Index keeps 1 of every N subpaths; Random keeps a stable random subset (hashed on index, so shapes don't flicker in/out — raising Amount reveals more of the same subpaths, Seed re-rolls the selection). Invert flips which side is kept. Anchors are never touched, so surviving subpaths keep their exact geometry, group tags, and drivers.
Parameters
Name
Type
Default
Mode
mode
enum
"bbox"
bbox · mask · size · index · random
X min
x_min
scalar
-1 … 2
0
X max
x_max
scalar
-1 … 2
1
Y min
y_min
scalar
-1 … 2
0
Y max
y_max
scalar
-1 … 2
1
Test
test
enum
"center"
center · inside · overlap
Threshold
threshold
scalar
0 … 1
0.5
Sample
mask_sample
enum
"center"
center · average
Metric
size_metric
enum
"length"
length · area
Min
size_min
scalar
0 … 4
0
Max
size_max
scalar
0 … 4
4
Keep 1 of every
every
scalar
1 … 32
2
Offset
offset
scalar
0 … 32
0
Amount
amount
scalar
0 … 1
0.5
Seed
seed
scalar
0 … 999
0
Invert
invert
boolean
false
Sockets
Direction
Name
Type
input*
path
path
spline
input
Mask
mask
image
outputprimary
out
spline
Modulate Splines
modulate-splinespolymorphic
Per-subpath scale and rotation around each subpath's centroid. Uniform inputs apply to every subpath; image fields are sampled at the centroid UV. Drop after Copy to Points (spline mode) for per-instance Transform — each copy is its own subpath. Stack to layer modulations.
Parameters
Name
Type
Default
Scale × default
scale_mul_default
scalar
0 … 4
1
Rotate + default (rad)
rotate_add_default
scalar
-3.141592653589793 … 3.141592653589793
0
Scale field — black
scale_field_lo
scalar
0 … 4
0.5
Scale field — white
scale_field_hi
scalar
0 … 4
1.5
Rotate field amount (rad)
rotate_field_amount
scalar
0 … 3.141592653589793
3.141592653589793
Sockets
Direction
Name
Type
input*
splines
splines
spline
input
Scale × (uniform)
scale_mul
scalar
input
Rotate + (uniform)
rotate_add
scalar
input
Scale field
scale_field
image
input
Rotate field
rotate_field
image
outputprimary
out
spline
Offset Path
spline-offset
Offset each subpath perpendicular to its tangent. Useful for variable-width strokes and outline variants without rasterizing. When sharp corners make the offset overlap itself, the Overlap mode cuts the crossing loop — Sharp resolves it to a single point, Smooth rounds the cut.
Parameters
Name
Type
Default
Distance
distance
scalar
-0.5 … 0.5
0.02
Overlap
overlap
enum
"keep"
keep · sharp · smooth
Smoothing
smoothing
scalar
0 … 1
0.5
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
spline
Optimize Path
optimize-pathpolymorphic
Refit messy spline data — traces, scribbles, simulation output — to the fewest clean Bézier segments within a pixel tolerance. Corners sharper than the corner angle are preserved exactly; smooth spans are refit with far fewer anchors. Smoothing denoises jittery input before fitting (handle-less anchors only — authored geometry never moves); Cull specks drops subpaths shorter than the given length, the dust tracing leaves behind. Optimal mode searches for the true minimum segment count (slower — use for finals, not per-frame animation). Debug skeleton overlays the source path with the optimized result's anchors and handles (select the node to see it in the viewport) and mints it as an image output.
Parameters
Name
Type
Default
Tolerance (px)
tolerance
scalar
0.01 … 50
0.5
Mode
mode
enum
"adaptive"
adaptive · optimal
Corner angle (°)
corner_angle
scalar
1 … 89
30
Smoothing
smoothing
scalar
0 … 1
0
Cull specks (px)
cull_length
scalar
0 … 1000
0
Debug skeleton
show_debug
boolean
false
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
spline
Rasterize Spline
rasterize-spline
Rasterize a spline as fill, stroke, or both in a single pass. Fill draws underneath the stroke. Toggle each independently. Fill and stroke colors can each be a flat color or a per-subpath ramp keyed by index, seeded random, group, centroid position, or driver — sourced independently, so e.g. fill by index and stroke by random. A wired fill image can drive the fill, the stroke, or both via the Image → fill / Image → stroke toggles. Per-anchor width (Spline Draw's Width tool) rides the spline: Thickness is the base, each anchor's width is a multiplier on it.
Repeat a path as parallel-offset copies — count, inner/outer/both direction, band width, and a spacing curve that places each copy within the band. Closed shapes are winding-normalized (outer always expands); for open paths inner/outer mean left/right of the travel direction. Each copy is tagged with its own group index. When sharp corners make an offset copy overlap itself, the Overlap mode cuts the crossing loop — Sharp resolves it to a single point, Smooth rounds the cut.
Redistribute anchors evenly along the arc length of the spline. Preserves subpath count and closed/open state.
Parameters
Name
Type
Default
Anchors per subpath
count
scalar
2 … 512
16
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
spline
Rigid Body Simulator
rigid-body-simulatorpolymorphic
2D rigid body dynamics: each input subpath becomes a rigid body that falls, tumbles, and stacks — colliding with collider nodes, the canvas bounds, and other bodies (edge-accurate contacts). Glue makes touching bodies bond and snap apart under stress. Rigidity below 1 turns bodies to jelly. At full rigidity the output is your original curves under each body's rotation + translation. Resets when scene time returns to 0.
Parameters
Name
Type
Default
Segment length (px)
segment_px
scalar
2 … 64
8
Max points
max_points
scalar
16 … 32768
2000
Pin ends
pin_mode
enum
"none"
none · start · end · both
Pin capture radius (px)
pin_radius
scalar
2 … 64
12
Follow input
follow_input
boolean
false
Gravity X
gravity_x
scalar
-2 … 2
0
Gravity Y
gravity_y
scalar
-2 … 2
0.35
Rigidity
rigidity
scalar
0.05 … 1
1
Damping
damping
scalar
0 … 1
0.02
Friction
friction
scalar
0 … 1
0.2
Bounciness
bounciness
scalar
0 … 1
0.2
Glue
glue
scalar
0 … 1
0
Glue break (px)
glue_break
scalar
0.5 … 64
6
Body collisions
body_collide
boolean
true
Self-collision
self_collide
boolean
false
Thickness (px)
thickness
scalar
1 … 32
4
Friction map: live
friction_map_live
boolean
false
Bounce map: live
bounce_map_live
boolean
false
Glue map: live
glue_map_live
boolean
false
Substeps
substeps
scalar
1 … 16
6
Iterations
iterations
scalar
1 … 16
6
Frame dt
fixedDt
scalar
0.001 … 0.1
0.016666666666666666
Force slots
forceCount
scalar
0 … 6
1
Collider slots
colliderCount
scalar
0 … 6
1
Canvas bounds
boundsMode
enum
"off"
off · bounce · clamp
Bounds bounce
boundsRestitution
scalar
0 … 1
0.5
Output
output_mode
enum
"smooth"
smooth · polyline
Sockets
Direction
Name
Type
input*
splines
splines
spline
input
force1
force1
force
input
collider1
collider1
collider
input
pins
pins
points
input
friction_map
friction_map
mask
input
bounce_map
bounce_map
mask
input
glue_map
glue_map
mask
input
pin_map
pin_map
mask
outputprimary
out
spline
outputaux
bodies
points
outputaux
points
points
outputaux
snaps
points
Rope Simulator
rope-simulatorpolymorphic
2D rope/string dynamics: each input subpath becomes a chain of particles with distance and bending constraints, pulled by gravity and force nodes, colliding with collider nodes and the canvas bounds. Pin the ends and the rope hangs and swings; output is a live spline. Resets when scene time returns to 0.
Parameters
Name
Type
Default
Segment length (px)
segment_px
scalar
2 … 64
8
Max points
max_points
scalar
16 … 32768
2000
Pin ends
pin_mode
enum
"both"
none · start · end · both
Pin capture radius (px)
pin_radius
scalar
2 … 64
12
Follow input
follow_input
boolean
false
Gravity X
gravity_x
scalar
-2 … 2
0
Gravity Y
gravity_y
scalar
-2 … 2
0.35
Stiffness
stiffness
scalar
0 … 1
0.1
Damping
damping
scalar
0 … 1
0.02
Friction
friction
scalar
0 … 1
0.2
Bounciness
bounciness
scalar
0 … 1
0.3
Stretchiness
stretchiness
scalar
0 … 1
0
Stickiness
stickiness
scalar
0 … 1
0
Stick strength
stick_strength
scalar
0 … 5
1
Self-collision
self_collide
boolean
true
Thickness (px)
thickness
scalar
1 … 32
4
Tearing
tearing
boolean
false
Tear threshold
tear_threshold
scalar
0.01 … 4
0.5
Friction map: live
friction_map_live
boolean
false
Bounce map: live
bounce_map_live
boolean
false
Stretch map: live
stretch_map_live
boolean
false
Tear map: live
tear_map_live
boolean
false
Stick map: live
stick_map_live
boolean
false
Substeps
substeps
scalar
1 … 16
4
Iterations
iterations
scalar
1 … 16
4
Frame dt
fixedDt
scalar
0.001 … 0.1
0.016666666666666666
Force slots
forceCount
scalar
0 … 6
1
Collider slots
colliderCount
scalar
0 … 6
1
Canvas bounds
boundsMode
enum
"off"
off · bounce · clamp
Bounds bounce
boundsRestitution
scalar
0 … 1
0.5
Output
output_mode
enum
"smooth"
smooth · polyline
Sockets
Direction
Name
Type
input*
splines
splines
spline
input
force1
force1
force
input
collider1
collider1
collider
input
pins
pins
points
input
friction_map
friction_map
mask
input
bounce_map
bounce_map
mask
input
stretch_map
stretch_map
mask
input
tear_map
tear_map
mask
input
stick_map
stick_map
mask
input
pin_map
pin_map
mask
outputprimary
out
spline
outputaux
points
points
outputaux
tears
points
Round Corners
round-corners
Round the sharp corners of a spline with circular fillets. Radius is in normalized space (0.5 = half the canvas), capped per corner at half each edge. Curved anchors and open-path endpoints are left as-is. Outputs a spline — view it with Stroke or Rasterize Spline.
Parameters
Name
Type
Default
Radius
radius
scalar
0 … 0.5
0.04
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
spline
Sample Along Path
sample-along-path
Output the position, tangent, and orientation angle at a given arc-length t ∈ [0,1] along a spline. Expose `t` as a socket to animate along the path; set Past ends to loop/ping-pong so `t` past 1 repeats. Wire `angle` (radians, tangent direction) or `normalAngle` (perpendicular) into a rotation input to orient an object along the path.
Parameters
Name
Type
Default
t
t
scalar
0 … 2
0
Past ends
wrap
enum
"clamp"
clamp · loop · ping-pong
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
vec2
outputaux
tangent
vec2
outputaux
angle
scalar
outputaux
normalAngle
scalar
Set Spline Type
set-spline-type
Convert a spline's anchors between linear (handles stripped — a polyline) and smooth (catmull-rom auto handles through every anchor, scaled by tension). Positions, closed state, and groups are unchanged.
Parameters
Name
Type
Default
Type
spline_type
enum
"smooth"
linear · smooth
Tension
tension
scalar
0 … 2
1
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
spline
Spline Boolean
spline-booleanpolymorphic
Boolean of two splines. Subtract (A − B) cuts B out of A's filled region; also union, intersect, and exclude (XOR). For subtract/intersect, 'Treat A as line' cuts A's curves instead — gaps where B covers them (subtract) or only the covered arcs (intersect), keeping true bezier geometry. Outputs a spline, plus an image when stroke or fill is on.
Parameters
Name
Type
Default
Opacity
opacity
scalar
0 … 1
1
Operation
operation
enum
"subtract"
subtract · union · intersect · exclude
Treat A as
treat_a
enum
"shape"
shape · line
Curve resolution
resolution
scalar
3 … 96
24
Stroke
stroke_enabled
boolean
false
Thickness (px)
stroke_thickness
scalar
0 … 200
4
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
true
Fill color
fill_color
color
"#ffffff"
Fill fit
fill_fit
enum
"window"
window · contain · cover
Sockets
Direction
Name
Type
input*
A (base)
a
spline
input
B (cut)
b
spline
input
fill
fill
image
outputprimary
out
spline
outputaux
image
image
Spline Flow Field
spline-flow-field
Turn a drawn spline into a divergence-free velocity field (encoded as a signed-RG image, midlevel 0.5): content wired through Advect Image / Advect Points (field mode `vector`) / Displace streams along the curve. `along` mode flows down the path's direction inside a ribbon of `width`; `orbit` circulates around the whole stroke like a vortex filament. Negative strength reverses the flow. Chain fields through the optional `field` input (e.g. Perlin Noise curl for ambient turbulence + this for direction) — contributions sum into one flow. The field has no sources or sinks by construction, so advected content swirls instead of piling up.
Parameters
Name
Type
Default
Mode
mode
enum
"along"
along · orbit
Strength
strength
scalar
-2 … 2
0.5
Width
width
scalar
0.005 … 0.5
0.06
Softness
softness
scalar
0.05 … 2
0.5
Samples
samples
scalar
8 … 96
48
Sockets
Direction
Name
Type
input*
spline
spline
spline
input
Field (add)
field
image
outputprimary
out
image
Spline Interpolate
spline-interpolatepolymorphic
Interpolate between 2 or more splines. Feed shapes into the auto-growing sockets (there's always one spare) and get a single spline containing the inputs plus a set number of interpolated in-betweens, spread evenly across the whole sequence. Shapes are auto-aligned by orientation and start vertex; each output subpath is groupIndex-tagged in order for Select by Index / Copy-to-Points. Wire a spline into the Spine socket to distribute the whole family along it (the Illustrator Blend-along-a-path move), optionally rotated to the spine's tangent.
Parameters
Name
Type
Default
In-betweens
count
scalar
0 … 200
5
Resolution
resolution
scalar
3 … 256
64
Align to spine
spine_align
boolean
true
Sockets
Direction
Name
Type
input
Spline
in
spline
input
Spine
spine
spline
outputprimary
out
spline
Spline Merge
spline-merge
Merge all subpaths of one spline into combined region(s). Union collapses overlapping shapes into a single silhouette (one clean outer stroke when rasterized); also intersect and exclude (even-odd XOR). Flow turns the merge into a liquid simulation — the silhouette flows toward the new shape, bridging and snapping as parts meet and stretching before it pinches off as they part. Outputs a spline — wire into Rasterize Spline to draw. Note: union treats each subpath as solid, so holes inside a single shape fill in.
Parameters
Name
Type
Default
Operation
operation
enum
"union"
union · intersect · exclude
Curve resolution
resolution
scalar
3 … 96
24
Flow
flow
boolean
true
Flow Speed
flow_speed
scalar
0 … 1
0.3
Surface Tension
tension
scalar
0 … 1
0.35
Adhesion
adhesion
scalar
0 … 1
0.5
Blend
blend
scalar
0 … 0.25
0.06
Detail
detail
scalar
128 … 768
320
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
spline
Spline Morph
spline-morphpolymorphic
Morph (tween) between two or more splines by Amount (0 = first, 1 = last). Extra spline sockets auto-grow; Amount is split evenly across the chain (3 shapes → 0 / 0.5 / 1). Shapes are auto-aligned by orientation and start vertex; surplus subpaths grow/shrink from a point. Outputs a spline, plus an image when stroke or fill is on.
Parameters
Name
Type
Default
Opacity
opacity
scalar
0 … 1
1
Amount
amount
scalar
0 … 1
0.5
Resolution
resolution
scalar
3 … 256
64
Stroke
stroke_enabled
boolean
false
Thickness (px)
stroke_thickness
scalar
0 … 200
4
Stroke color
stroke_color
color
"#ffffff"
Fill
fill_enabled
boolean
true
Fill color
fill_color
color
"#ffffff"
Sockets
Direction
Name
Type
input
A
a
spline
input
B
b
spline
input
Amount
amount
scalar
outputprimary
out
spline
outputaux
image
image
Stroke
spline-stroke
Render a spline as a stroked outline. Three styles: solid (continuous), dashed (alternating dashes and gaps), dotted (round dots at a fixed spacing). Color source can be a flat color or a per-subpath ramp keyed by index, seeded random, group, or centroid position — the same sourcing the fill has. Thickness source varies each subpath's width the same way (a lo→hi multiplier on the base thickness) — with Copy to Points' 'Tag copies: copy index', every copy gets its own stroke weight. Repeats draws N parallel-offset rings — inner/outer/both, a band width, and a spacing curve placing each ring within the band (closed shapes always expand outward regardless of draw direction; for open paths inner/outer mean left/right of travel). Per-ring styling: thickness and opacity falloff curves, plus an optional color ramp across the rings (which takes precedence over the per-subpath color source).
Reveal only a portion of a path by arc length. Start/end (0–1, across all subpaths) animate a draw-on; offset slides the window along the path, wrapping past the ends (unbounded — keyframe it to orbit the piece around a loop). Outputs a spline — view it with Stroke or Rasterize Spline.
Parameters
Name
Type
Default
Trim start
trim_start
scalar
0 … 1
0
Trim end
trim_end
scalar
0 … 1
1
Trim offset
trim_offset
scalar
-1 … 1
0
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
spline
Utilities
Bezier Handles
bezier-handles
Visualize a spline's bezier control structure like a pen-tool editor view: the path (optional), the tangent handle lines, anchor dots, and handle-end dots — each independently styled (color/thickness/dashed·dotted for lines; radius/fill/stroke for dots). Outputs both an image (primary) and a spline (aux: the handle lines + dots as vectors, group-tagged 0=lines, 1=anchors, 2=handles).
Parameters
Name
Type
Default
Show path
show_path
boolean
true
Path color
path_color
color
"#8a8a8a"
Path width (px)
path_width
scalar
0 … 50
1.5
Show handle lines
show_handles
boolean
true
Handle color
handle_color
color
"#4a90ff"
Handle width (px)
handle_width
scalar
0 … 50
1
Handle style
handle_style
enum
"solid"
solid · dashed · dotted
Dash length (px)
handle_dash
scalar
0.5 … 200
6
Dash gap (px)
handle_gap
scalar
0.5 … 200
4
Dot spacing (px)
handle_dot_gap
scalar
1 … 200
6
Show anchor dots
show_anchor_dots
boolean
true
Anchor radius (px)
anchor_radius
scalar
0 … 50
4
Anchor fill
anchor_fill
boolean
true
Anchor fill color
anchor_fill_color
color
"#ffffff"
Anchor stroke
anchor_stroke
boolean
true
Anchor stroke color
anchor_stroke_color
color
"#4a90ff"
Anchor stroke (px)
anchor_stroke_width
scalar
0 … 50
1.5
Anchor stroke style
anchor_stroke_style
enum
"solid"
solid · dashed · dotted
Dash length (px)
anchor_stroke_dash
scalar
0.5 … 200
6
Dash gap (px)
anchor_stroke_gap
scalar
0.5 … 200
4
Dot spacing (px)
anchor_stroke_dot_gap
scalar
1 … 200
6
Show handle dots
show_handle_dots
boolean
true
Handle dot radius (px)
cp_radius
scalar
0 … 50
3
Handle dot fill
cp_fill
boolean
true
Handle dot fill color
cp_fill_color
color
"#4a90ff"
Handle dot stroke
cp_stroke
boolean
false
Handle dot stroke color
cp_stroke_color
color
"#ffffff"
Handle dot stroke (px)
cp_stroke_width
scalar
0 … 50
1
Handle dot stroke style
cp_stroke_style
enum
"solid"
solid · dashed · dotted
Dash length (px)
cp_stroke_dash
scalar
0.5 … 200
6
Dash gap (px)
cp_stroke_gap
scalar
0.5 … 200
4
Dot spacing (px)
cp_stroke_dot_gap
scalar
1 … 200
6
Opacity
opacity
scalar
0 … 1
1
Sockets
Direction
Name
Type
input*
path
path
spline
outputprimary
out
image
outputaux
spline
spline
SVG Export
svg-export
Save the wired spline as a standalone .svg file, snapshotted at the current playhead. Styling (stroke width/color, fill color and rule) is set here — the exported path carries it. The spline passes through unchanged, so the node can sit inline in a chain.