Accumulator
accumulatorIntegrate a scalar over time. Output grows or oscillates as the input accumulates each frame. Auto-resets on scene time 0; an optional reset input clears to the initial value while held.
Parameters
Sockets
loading docs
Cross-type helpers: scalar math, vec2 packing, grouping, arraying, and polymorphic transforms that work on image / spline / point inputs.
accumulatorIntegrate a scalar over time. Output grows or oscillates as the input accumulates each frame. Auto-resets on scene time 0; an optional reset input clears to the initial value while held.
animated-valueA keyframable value with a wired clock: keyframe Value as usual, then wire a scalar into Time and the curve is sampled at that time instead of the playhead — offset it, stretch it, ping-pong it, or drive it from audio. Unwired, it behaves like a keyframed Constant. Unit sets whether Time is read as frames or seconds.
arraypolymorphicTile an image, spline, or points into a grid. Image mode supports modulator inputs for per-cell scale/position/rotation variation; spline / point modes emit transformed CPU geometry — feed Displace or Transform downstream for noise / uniform tweaks.
bounding-boxpolymorphicMeasure the bounding box of an image (alpha extent), mask, spline, or points and output it as edge scalars, midpoint/corner points, the box as a spline, and optional full-canvas guide lines.
clampClamp a scalar into [Lo, Hi]. Lo and Hi can be wired or set in the panel; if Lo > Hi they are swapped before clamping.
color-literalpolymorphicEmits one or more colors as vec4 values (not images). The + on the node header adds another color output; each color square on the node opens a picker in place, and the H/S/L/A row at the bottom edits whichever square is selected. Wire an image into the palette input and the outputs switch to a palette extracted from it (color 1 = most dominant). Use to drive color-math nodes or any exposed color param.
collectpolymorphicBundle N homogeneous inputs. For images, produces an image_group. For splines and points, concatenates into a single value with per-subpath / per-point groupIndex metadata matching the socket order (a=0, b=1, c=2…). Nodes that don't understand groupIndex just treat the output as a normal spline/points value; Select by Index and Count Indices key off the tags. For 3D objects, groups the inputs into one object3d for the 3D Scene node — primitives wire straight in.
combine-vec2Build a vec2 from two scalars. Inputs default to the x/y params when unconnected, so the node also doubles as a vec2 constant.
compareCompare two scalars with one of >, <, ≥, ≤, ==, !=. Output is 1 (true) or 0 (false). Equality variants use an epsilon window so floating-point fuzz doesn't flip results.
constantEmits a single scalar value, in float or integer mode, snapped to a configurable step (2 → 2, 4, 6…; 1.2 → 1.2, 2.4, 3.6…). Use to feed exposed scalar inputs without routing through a Math node.
group-lengthpolymorphicCount distinct group members as a scalar. Image mode counts image_group items; spline and points modes count distinct groupIndex values carried on subpaths / points (un-grouped input reports 1).
csvpolymorphicLoads a CSV and exposes each column as an output socket carrying the cell at the selected row. Numeric columns emit scalars, text columns emit strings (wire straight into a Text node's exposed text). Drive the row to step through the data.
draggableMake a shape grabbable: wire the shape's mask into handle, its offset output into a Transform translate on the same shape, and the shape drags by hand — editor and exported apps alike. The hit test follows the moved shape with no feedback cycle (it samples the un-translated mask at cursor − offset). Aux: held / hover / press / click. Reset input snaps back to rest.
expressionpolymorphicType a JavaScript math expression instead of wiring a chain of Math nodes. Each input socket is a named variable (x, y, z…); the + adds more. Outputs a scalar or vector. Globals: t, frame, PI, TAU, sin, cos, clamp, lerp, smoothstep, random, and the rest of Math.
float-curveRemap a scalar through an editable curve: the input is x in [0..1], the output is the curve's y there. Inputs outside 0..1 hold the endpoint values. Use Remap to bring other ranges into 0..1 first.
hit-regionTurn any shape into a button: gates pointer signals on a mask region (wire a Circle, Text, SVG, or any spline — the silhouette becomes the hit area). Outputs hover, and press / click / release / held for gestures that STARTED inside, with real button grab semantics (leaving mid-drag doesn't drop the gesture). drag_delta tracks the owned gesture — Hit Region → Trigger Envelope is an interactive button; drag_delta → Transform is a crude handle.
lerppolymorphicLinear interpolation (mix) between A and B by t. Works on scalars, vec2, points sets, or splines (matching counts required for points/splines). t can be wired or set in the panel; Clamp restricts it to [0..1].
lfoPeriodic scalar oscillator — sine, triangle, sawtooth, or square. Frequency is in Hz, phase is in cycles. Output rides in [-amplitude, +amplitude] + offset.
listpolymorphicParses pasted or loaded text into a list — newlines, commas, tabs, pipes, semicolons, JSON arrays, bulleted/numbered lists, or range shorthand (1..10, a..e, 0..20 step 2). Outputs the whole list for the list transform nodes, plus the item at an animatable index (a scalar for numeric lists, a string otherwise) and the item count.
logicpolymorphicBoolean gate over scalar inputs. Any non-zero is treated as true. Output is 1 (true) or 0 (false). Ops: and, or, xor, not (1-input).
mathpolymorphicScalar math: arithmetic, comparison, rounding, trig, and conversion. Each input can be a connected scalar or a value typed in the panel.
mirrorpolymorphicMirror a spline or points across the X / Y axis (or both), or repeat them radially around a center with a count slider — with an optional kaleidoscope reflection per wedge. Copies can tag groupIndex per copy for ramp-by-group fills or Group Pick downstream.
number-to-stringFormats a number as text — decimal places, zero-padding, thousands separators, prefix/suffix. Wire it into a Text node's text to show an animated value (counters, scores, percentages).
pointerMouse / touch interaction signals: cursor position (authored space), press / release / click pulses, held and drag-active levels, per-gesture drag delta, and an accumulated drag offset with axis lock and sensitivity — the virtual-scrub control. Click vs drag is split by the slop threshold. Wire click into Trigger Envelope for motion, drag_offset into a Transform translate, press into an Accumulator for click counting.
proximity-mergepolymorphicCombine multiple splines (or point sets) and weld the parts that fall within a distance threshold in UV space. Join stitches open subpath endpoints into continuous / closed paths (a real topology change); Snap clusters nearby anchors/points to their shared centroid. Inputs auto-grow — there's always one spare empty socket — and a single socket also accepts a spline group from the Combine node. Animate exposes a `t` scalar (0..1) that slides parts together, committing the join/collapse at t=1 with no pop.
randompolymorphicRandom scalar or vec2. Seeded mode is deterministic per frame; Frame mode re-rolls each eval. Uniform draws from [Lo, Hi]; Gauss returns normals centered on (Lo+Hi)/2 with ±3σ ≈ Hi-Lo.
relaxpolymorphicIteratively even out geometry. Points: push apart every pair closer than the radius (de-clump a Scatter). Splines: Laplacian-smooth anchor positions along each subpath (endpoints pinned, closed wraps; handles unchanged). Mix blends back toward the original.
remappolymorphicRemap an input from [in_min, in_max] to [out_min, out_max]. Mode chooses between Scalar (CPU value) and Image (per-pixel shader) for the primary path. The Input Field socket + Field output are always available — wire a scalar_field in to get a remapped scalar_field out, inlined into the SDF shader.
sample-holdpolymorphicLatch a value on each rising edge of the trigger and hold it until the next one. Latch the Pointer's position on click, an audio level on a beat, a Random per press. Type retypes the value socket (scalar / vec2 / vec3 / vec4). Follow mode passes the input through until the first trigger; zero rests at 0.
scene-timeEmits the current playback time as a scalar in seconds or frames. Modes: linear, ping-pong (period in frames + amplitude + min/max, with an easing curve on each ramp), or stepped with easing. Connect to an exposed scalar input to drive animation.
sdf-bevelTerminal that rasterizes an SDF with two-light bevel shading. Outer / Inner / Emboss / Pillow styles. Each light has its own angle / elevation / opacity; highlight + shadow colors and blend modes are shared. Replaces SDF Rasterize when you want a 3D-button or relief look.
sdf-circleSDF primitive — a circle of radius r at (x, y). Wire `position` to feed a transformed coordinate space (Translate / Repeat / Mirror / etc.) — unwired defaults to canvas UV.
sdf-displaceModifier — perturb the distance field by sampling an image's red channel. Sampled value [0..1] remaps to [-Amount..+Amount] and adds to the distance. Wire a Noise output for wobbly edges; wire a mask for a hard cutout.
sdf-from-imageConvert an image into a signed distance field. Distance mode thresholds a channel and runs a jump-flooding distance transform (inside negative); Raw mode treats the image as an already-baked distance field (0.5 = edge). Output composes with Union / Morph / Round / Rasterize.
sdf-intersectionBoolean intersection of two SDFs (max). Result is inside only where both A and B are inside.
sdf-line-segmentSDF primitive — a thick line (capsule) between (Ax, Ay) and (Bx, By) with the given thickness. Endpoints are rounded. Wire `position` to feed a transformed coordinate space.
sdf-materialPaint an SDF subtree. Sets the color every shape below it renders with, unless a shape (or a nearer Material) paints itself. Distance is untouched. Constant mode takes a color (or a wired Color node); Ramp mode samples a gradient at a scalar field — wire SDF Repeat's Cell ID through a noise node to give every tile its own color.
sdf-mirrorSDF position-pipeline op — reflect the sample position about X, Y, or both axes through the center.
sdf-morphMorph between two SDFs by interpolating their distance fields (mix). Amount 0 = A, 1 = B; topology can change mid-morph. Keyframe or wire Amount to animate.
sdf-onionModifier — turn the SDF into a hollow shell of the given thickness. Stack multiple Onions for concentric rings.
sdf-polarSDF position-pipeline op — fold the sample position into N rotational sectors around the center. Compose with Mirror for kaleidoscope symmetry.
sdf-polygonSDF primitive — a regular N-gon. Sides 3 = triangle, 4 = square, 5 = pentagon, 6 = hexagon… Wire a scalar field into Sides Field for per-pixel / per-tile variation in side count (set Quantize Sides on for clean integer counts; pair with SDF Repeat.cell_id → Noise for per-tile randomness).
sdf-rasterizeSample an SDF at every pixel and produce an image. Foreground / Background colors fill inside / outside; Contour adds an outline at the zero-crossing. One shader compile + one draw call total per topology.
sdf-rectangleSDF primitive — a rectangle (with optional rounded corners) centered at (x, y) with the given width × height. Wire `position` to feed a transformed coordinate space.
sdf-repeatSDF position-pipeline op — tile the sample position. Infinite by default; toggle Bounded for a finite tile count. Use the Jitter params for per-cell pseudo-random rotation / position / scale (each tile varies independently — what wiring an upstream Noise scalar into SDF Rotate cannot give you).
sdf-rotateSDF position-pipeline op — rotate the per-pixel sample position around a pivot. Wire a scalar field into Angle for per-pixel rotation (per-tile when paired with SDF Repeat.cell_id → SDF Noise).
sdf-roundInflate the boundary of an SDF by `radius`. Sharp corners become rounded; the entire shape grows by radius. Negative radius shrinks it.
sdf-scaleSDF position-pipeline op — scale the per-pixel sample position around a pivot. The exposed scale matches the visible effect on downstream shapes.
sdf-shadeShading terminal for SDFs: fill, color bleed, relief lighting, glow and contours composited in one pass. Per-shape colors come from SDF Material / a primitive's Paint swatch; Fill Color is the fallback for unpainted shapes. Aux outputs expose the normal, height, glow and bleed layers for re-compositing.
sdf-smooth-intersectionSmooth intersection of two SDFs. Smoothness rounds the corners where boundaries meet — same as Smooth Union, but for intersection (max).
sdf-smooth-subtractionSmooth subtraction (A − B) with a rounded cut. Smoothness blends the boundary where B carves into A — at 0 it degenerates to plain Subtraction.
sdf-smooth-unionpolymorphicSmooth (blob) union of any number of SDFs. Smoothness sets the blend width — when boundaries come within Smoothness of each other they merge into a curved metaball-style join. Inputs auto-grow: wire the empty socket and another appears.
sdf-splineSDF primitive — signed distance to a spline (flattened to line segments on CPU, looped per-pixel in the SDF shader). Closed splines compose like polygons (use Round / Smooth Union / etc.); open splines act as strokes (unsigned distance — wrap with Round to expand into a fill). Cap is 1024 segments; lower Subdivisions if you have many anchors.
sdf-starSDF primitive — an N-pointed star. Sharpness 2 = sharpest spike, equal-to-points = regular polygon. 3 ≤ Points ≤ 24. Wire `position` to feed a transformed coordinate space.
sdf-subtractionBoolean subtraction (A − B). Result is inside A but outside B — useful for cutting holes.
sdf-to-distance-imageRender an SDF as a grayscale distance visualization. Range sets how much of the field spans the full ramp — smaller values reveal fine detail near the boundary. Negative / Zero / Positive colors customize the ramp.
sdf-to-maskRender an SDF as a binary mask at the chosen iso-level (default 0 = the boundary). Softness feathers the edge in pixels. Invert flips inside ↔ outside. Output is an image suitable for any mask/image consumer.
sdf-to-splineExtract the iso-line of an SDF as a spline (closed where loops form, open where chains run off the grid). Resolution sets the marching-squares grid size — 256 is a good default; raise it for smoother curves at the cost of a bigger CPU readback. Async Readback trades a one-frame contour lag during playback for eliminating the sync GPU readback stall (the whole cost of this node in GPU-heavy graphs); exports are frame-exact either way.
sdf-translateSDF position-pipeline op — translate the per-pixel sample position. Feeds into a shape's `position` input. Default upstream position is canvas UV.
sdf-triangleSDF primitive — a triangle through three corners (A, B, C). For a regular triangle, prefer SDF Polygon with sides=3. Wire `position` to feed a transformed coordinate space.
sdf-twistSDF position-pipeline op — spiral the sample position around the center by Strength radians per unit distance. Strength accepts either a scalar (uniform per draw) or a scalar field (per-pixel; pair with SDF Repeat.cell_id → SDF Noise for per-tile variation). Large values violate the unit-gradient SDF property; a thin Rasterize contour line hides the resulting aliasing.
sdf-unionBoolean union of two SDFs (min). Result is inside if either A or B is inside. For a blended boundary use SDF Smooth Union.
group-pickpolymorphicFilter to one index of a group. For images, indexes into an image_group's array. For splines and points, keeps only subpaths / points whose groupIndex matches the chosen index — Group's output uses socket-order tags (a=0, b=1, c=2…). Index clamps to valid range.
smoothExponential smoothing filter on a scalar. Time is the smoothing time-constant (seconds) — larger values produce heavier damping. Useful for de-jittering tracker outputs (hand, object) or audio levels.
split-vec2Pull the x and y components out of a vec2 as scalars. Primary = x, aux = y.
string-literalEmits a single text value. Wire it into an exposed string param (e.g. a Text node's text) to drive that text, or share one string across several nodes.
switchpolymorphicPicks one of N inputs by index. Accepts any socket type: leave Type on "auto" and the node adopts whatever you wire in — mixed inputs coerce to the one type they share (a scalar beside a vec4 becomes vec4; a mask beside an image becomes image). Count sets how many slots render. Wire a scalar to Index for live switching.
time-offsetpolymorphicShifts everything upstream in time: the branch wired into it re-evaluates at the playhead minus Offset (in frames), so its keyframes, clips, and procedural animation play later — or earlier with a negative offset. Wire or keyframe Offset for time-warping. Live and simulated nodes upstream (video, webcam, audio, cursor, sims) can't time-travel and pass through un-shifted.
transformpolymorphicScale, rotate, and translate the input around a pivot. Works on images, splines, or points. For SDFs use the Position-pipeline operators (Position Translate / Scale / Rotate) — they compose with Position Repeat / Mirror / Polar for tile-local transforms.
trigger-envelopeRising edge in, attack / hold / release envelope out (0→1→0 scalar). Stretches a one-frame pulse — a Pointer click, an audio beat, a Compare crossing — into usable motion. Wall clock responds while paused; timeline clock makes deterministic triggers export-exact. Retrigger restarts or ignores edges mid-envelope.
vec2-literalEmits a single vec2 value. Use to feed exposed vec2 inputs without routing through Combine Vec2.
vec3-literalEmits a single vec3 value.
wedgepolymorphicBatch-render variation source. Defines a set of values — scalar (explicit list, range, seeded random, or the bare iteration index), color, vec2, or string — and emits one per render when the export runs a wedge batch: wire it into a seed, a Switch index, a fill color, a Text string, or any exposed param. Outside a batch it emits the value at Preview, so scrubbing Preview auditions variations live. Multiple Wedge nodes zip: the batch runs max(counts) iterations and shorter wedges hold their last value.