3D Cube (Test)
cube-3d-testM0 render-bridge spike: a lit, spinning cube rendered by three.js on its own WebGL context and composited into the 2D graph. Proof-of-concept for the 3D context.
Parameters
Sockets
loading docs
Nodes whose primary output is a raster image — sources that generate pixels, and modifiers that transform them.
cube-3d-testM0 render-bridge spike: a lit, spinning cube rendered by three.js on its own WebGL context and composited into the 2D graph. Proof-of-concept for the 3D context.
cursorCircular falloff field centered on the pointer, plus an aux velocity field encoded as RG (direction × magnitude, modulated by the same falloff). Radius and softness are in fractions of canvas width — circular on any aspect.
fluid-simulatorpolymorphic2D Eulerian fluid (smoke / dye / ink in open water). Wire any mask/spline/shape into `deposit` to release dye; an image into `color` for its hues (alpha doubles as coverage when `deposit` is unwired). Takes the SAME force nodes as the Particle Simulator (Vortex/Wind/Gravity/Turbulence… — add slots in the panel) and Circle/Line/Image-Mask colliders as solid obstacles the flow routes around. The optional `field` input steers the fluid with an authored velocity field (Perlin curl / Spline Flow Field); the `velocity` aux emits the LIVE sim field in the same encoding, so Advect Points / Advect Image can ride the simulation. Advection-reflection keeps swirls energetic; `vorticity` adds small-scale swirl back. `buoyancy` makes dense dye rise (smoke). Runs while the timeline plays; restarting the timeline clears the tank.
gradientpolymorphicTwo-color gradient in linear, radial, polar or wave modes.
image-generateGenerate images via OpenAI's gpt-image-2 with a chat interface in the param panel. Bring-your-own OpenAI key (Toolbox → User Preferences). Three optional reference image inputs feed the model as context. Outputs the currently-selected generation, or transparent when none is selected.
image-sourceUploads an image and produces it as the canonical output. Accepts EXR files (single or multilayer, scene-linear HDR) with a layer picker.
noiseMulti-algorithm fBm noise. Three outputs: `image` (rasterized canvas-wide), `value` (CPU scalar sampled at the `position` input — single number per frame), and `field` (per-pixel scalar shader expression sampled at `field_position` — wire into SDF Rotate.angle_field / SDF Twist.strength_field for true per-pixel/per-tile modulation; pair with SDF Repeat.cell_id for per-tile variation). The `field` output uses simplex regardless of the `type` param; image and value paths respect type. The `UV` input re-evaluates the noise at coordinates read from the wired value's R/G — wire another Noise (or any image) in for Blender-style domain warping/marbling.
paintDraw on the main canvas while this node is selected — brush, eraser, blur, fill, and eyedropper tools with editable brushes.
physarumpolymorphicGPU slime-mold (Physarum) transport network. Millions of agents sense a decaying trail field ahead-left / ahead / ahead-right, turn toward the strongest, step and deposit; the field diffuses and decays, and self-optimising vein networks emerge. Uses Sage Jenson's 36 Points parameterisation — every classic parameter is `base + scale * sensed^power`, so one algorithm covers 24 wildly different regimes. Pick a `preset`, then ride the four multipliers on top of it: `sense scale` is the most expressive (it slides the whole system between regimes), `turn` and `sensor angle` reshape the branching, and `scale` sets structure size — raise `blur passes` with it, since structure size is really the ratio of agent stride to diffusion width and `scale` alone just makes agents outrun the field. `custom` opens all 15 raw numbers. `agents` is a quality knob, not a look knob (the deposit is density-normalised), and `resolution` is fidelity above ~740px of sim height and a zoom below it. Wire a mask into `inject` to draw structure the agents colonise. Turn on `two points` and wire a mask into `blend` to run two different presets in different parts of the frame with a continuous frontier — a Circle driven by the Cursor node reproduces the original's interactive pen. Plays while the timeline runs; restarting the timeline reseeds. Algorithm: Jones 2010 / mxsage 36 Points; implementation ported from Etienne Jacob's interactive-physarum (CC BY-NC-SA 3.0).
shape-cellsGrid of cells with nested concentric shape copies. Per-cell shape, copy count and base hue are seeded; copy scales animate over time. Pipe Scene Time into `time` to drive motion.
solid-colorFills the frame with a single color. The color square on the node opens a picker in place; the H/S/L/A row at the bottom nudges it without one.
textpolymorphicRenders text with a built-in transform. Wire a spline into the Path input to lay the text along it (Text on Path). Primary is the rasterized image; aux exposes an SDF (jump-flood) and the glyph outline as a spline.
texture-coordinateEmits the default per-pixel (u, v) as a UV field. Feed it into UV-aware generators (Image Source, Gradient, Perlin) — with Math in UV mode sitting in between to warp, offset, or animate the coordinates.
video-sourcepolymorphicLoad a video file and render its current frame. Sync the clock to scene time for deterministic playback (good for exports), or let it play on its own.
voronoipolymorphicWorley/Voronoi cells from one of three point sources — an infinite procedural lattice, a CPU-scattered set (image-density placement + Lloyd relaxation, the former Fracture node), or an external Points input. Renders F1 / F2-F1 / F2 / cell-id / mask / position modes with selectable distance metric, and emits the true cell geometry as aux outputs: cell polygons (grouped, with per-cell driver), deduped edges, vertices, centers (area-scaled points), and the Delaunay neighbor graph. Geometry is the euclidean diagram and ignores the lattice warp/UV inputs; the Cell Bow param bulges cell edges outward (bubbles) or inward (pebbles).
watercolor-inkpolymorphicCellular-automaton watercolor / sumi ink simulation (Zhang et al. 1999). Wire any mask/spline/shape into `deposit` to lay down ink; water spreads through fibrous paper (nijimi), suspended ink rides and diffuses with it, and ink fixes permanently where the water dries. Wire an image into `color` and the deposited ink keeps its hues (white = clear water; with `deposit` unwired the image's alpha doubles as coverage). Low concentration = thin ink that wicks far along fibers; high = dense marks. `water map` scales the delivered water per cell (wired alone = pre-wet the sheet, wet-on-wet); `ink map` scales pigment concentration per cell (needs water to ride — dry areas deliver nothing). Sample rate 0 = continuous contact; above 0, the input (e.g. a video frame) is stamped as a full wash every 1/rate seconds and left to bloom/dry between stamps. Plays while the timeline runs; restarting the timeline clears the sheet.
webcam-sourceLive webcam feed via getUserMedia. First eval triggers the browser permission prompt. Mirror toggle defaults on to match how video-chat tools render the feed.
adaptive-pixelatePixelate with a non-constant grid: block size is driven by a luminance map (the Size Map input, or the image's own luminance). Quadtree mode splits blocks 4-ways where the map calls for detail; lattice mode crowds full-span rows/columns; uniform mode is a plain grid. Emits one point per block (center, scale, level) for building systems downstream.
advect-imageFlow an image along a velocity field: each pixel back-traces `steps` samples through the field (re-sampled every step, so content follows the field's curves — unlike Displace's single push). Deterministic and scrub-safe: `distance` is the total flow, keyframe it 0→N to animate content streaming along the field. Field modes match Advect Points (`vector` = signed-RG velocity from Perlin curl / Spline Flow Field, `angle` = luminance heading, `gradient` / `contour` = flow toward / around brightness). Optional speed image multiplies flow by its luminance. The `uv` aux carries the final warp for reuse in any uv consumer.
lutApply a .cube 3D LUT (color grade) to the image. The optional log2 HDR shaper applies OCIO-baked (shaper + cube) LUTs to scene-linear footage.
asciipolymorphicRender the input image as a grid of glyphs — text characters from a palette string (any font), or each image in a connected image_group. Glyph and per-cell background colors source from flat / the cell's own color / a color ramp driven by index, seeded hash, position, brightness, or a wired image. Brightness remapping, per-cell modulators, and aux index/brightness outputs match the Array node's conventions.
autolayoutpolymorphicFigma-style auto layout: stacks element children horizontally or vertically with alignment, padding, and gap. Children size as fixed (layout units), hug-contents, or fill-container; the aux element output makes layouts nestable. Plain image wires coerce to full-canvas elements — use per-slot trim or a Frame node to size them.
bg-removeRemove the background from an image using BRIA's RMBG model running locally via Transformers.js. Bake captures the upstream input + alpha mask once; live `feather` / `threshold` params tweak the edge per frame without a re-bake. Outputs the cutout (primary) plus the mask as both a typed mask aux and a grayscale image aux.
bento-sliceSlice the image into bento-box rectangles (recursive cuts driven by a luminance map — the Size Map input, or the image's own luminance) and offset every piece along a seeded scatter direction by Fac: 0 = assembled, 1 = split apart. Animate Fac to assemble or shatter the image. Steps > 1 makes pieces travel an axis-aligned staircase (2 = slide in sideways, then drop into place), with one easing curve per step. Emits one point per piece at its animated center for driving systems downstream.
bevel-embossBevel & Emboss — fake-3D raised edge from a height source. Outer / Inner / Emboss / Pillow Emboss styles. Two lights (each with angle, elevation, opacity) shade the height field with shared highlight + shadow colors and blend modes. Outer/Inner/Pillow use a JFA-derived signed-distance height (cached per input image); Emboss uses the input's luminance directly.
bloomMip-chain bloom (COD / UE5 / Unity HDRP technique). Soft-knee threshold + Karis-average downsample + 9-tap tent upsample give a crisp bright core with hundreds of pixels of soft tail at constant cost. Optional per-mip tint, anamorphic stretch, and lens dirt overlay. Quality picks where the pyramid starts: balanced/performance trade the glow's finest detail octave(s) for most of the pre-composite GPU cost, keeping the halo width unchanged.
blurpolymorphicBlur with selectable kernel. Gaussian for a plain soft blur, or Bokeh for true circular apertures (disc, ring, soft) with the flat-topped shape and hot rim a Gaussian cannot produce. Filters in premultiplied linear light.
chromatic-aberrationSplit the red and blue channels away from green to fake lens dispersion or a glitchy RGB shift. Radial (grows from a center) or directional (uniform angled shift).
shock-filterPainterly sharpening: smooths ALONG the image's flow while pushing pixels toward their local light/dark extreme ACROSS it, so soft gradients collapse into crisp, fluid brush edges — the operator behind most 'hand-painted' looks; stack after Kuwahara or Flow Bilateral. Steered by the `field` input (Image Flow Field or any velocity field) or an internal estimate when unwired. `Iterations` compounds the effect (deterministic — safe to scrub and export), `Radius` sets how far the sharpening reaches, `Smooth along` the per-iteration flow smoothing, `Amount` blends the shock against the smoothed base.
color-correctionHue, saturation, brightness, contrast, and per-channel RGB curves.
color-rampRemaps the input's luminance through a gradient of user-defined color stops.
color-space-transformConvert between color spaces (sRGB, linear, ACEScg, ACES2065-1, Rec.709, Display P3) with an optional view transform (ACES / AgX / Filmic tone mapping) — the display step for scene-linear EXR renders.
datamoshGlitch-melt two clips into each other. Wire two image inputs, then in the panel Bake each clip into the node, drag the two clips on the mini-timeline so they overlap, and the overlap is moshed: the incoming clip's motion warps a frozen frame of the outgoing clip (optical-flow advection). Flow Scale sets the smear distance, Smear its length, Decay its falloff, Refresh how fast the real incoming pixels bleed back. Preview plays forward live; Mosh bakes the result for clean scrubbing and export. (Inputs are session-only — reopen → re-bake.)
depth-anythingEstimate a depth map from an image locally via Transformers.js (Depth Anything V2). The header toggle switches the output between the depth map (grayscale, near=white) and a normal map derived from the depth gradient. Invert flips near/far; Near/Far set the depth black/white points. For animated inputs, Preview runs depth on the current frame and Bake runs the model over an in/out frame range and caches a depth map per frame (held in memory for this session — reopen → re-bake). Note: the model normalizes each frame independently, so brightness can drift over a clip.
displacepolymorphicOffset by a vector read from a displacement field. Wire an image and each pixel is pushed; wire a spline or points value and each anchor/point is pushed (sampled at its own UV). Channel X/Y pick the per-axis channels (RG vector field, or luminance for both); midlevel is the neutral value (0.5 for signed maps).
ditherQuantize the input image with error-diffusion or ordered dithering.
edge-detectExtract edges via Sobel or Prewitt 3×3 gradient convolution. Output is grayscale gradient magnitude — brighter = stronger edge. Threshold clamps weak responses to zero for binary edge maps.
flow-bilateralEdge-preserving smoothing aligned to the image's flow: a 1D bilateral filter runs across the local edge direction, then along it, per iteration — flattening texture and noise while edges and flowing detail survive. Much cheaper than a full 2D bilateral and calmer on video. The abstraction base of the toon look (follow with Posterize and Line Art). Steered by the `field` input (Image Flow Field or any velocity field) or an internal estimate when unwired. `Spatial σ` is the smoothing reach in px, `Range σ` how different colors must be to count as an edge (lower preserves more), `Across scale` shrinks the across-edge reach to protect edges harder.
flow-blurSmear the image along a flow field's streamlines (line integral convolution) — the painterly Van Gogh blur, and the standard way to SEE a field (wire noise into the image input). With `field` unwired the node derives flow from the image itself (structure tensor at `Internal smooth`); wire an Image Flow Field, Perlin curl, Spline Flow Field, or a sim's velocity aux to steer it. `Length` is the total ± smear distance (canvas-width fraction), `Samples` the quality per side. `Tangent` mode follows edge orientation regardless of direction; `Velocity` mode follows a directed field, smearing further where it's faster.
flow-obstacleMake a velocity field respect a shape: wire a field (Perlin Noise curl / Spline Flow Field) and an obstacle mask (any spline or shape coerces in), and flow deflects around the silhouette instead of passing through it. `deflect` redirects flow to slide along the boundary (and stalls it inside); `block` just damps flow by coverage for a dead-water stop. `radius` sets how far out the boundary's influence reaches — blur the mask upstream for an even softer approach. Chain several obstacles in series for multiple shapes.
glsl-expressionpolymorphicWrite the body of a GLSL fragment shader and run it as one fullscreen pass — the per-pixel counterpart to Point Expression. Read wired images with texture(u_a, v_uv) (u_b–u_d), the clock with u_time/u_frame, and canvas size with u_res; write fragColor with straight alpha. Declare tunables as // ch("name", default, min, max) comments and hit Sync to mint sliders that are also wireable inputs, readable as float uniforms. A compile error shows once in the console and the output follows On error.
grainProcedural film grain with separate luminance and chromatic channels. Works as a stand-alone grain source (no input → grain on 50% gray) or as a one-shot composite over an input image with a choice of mix modes. Animate Seed (e.g. wire Scene Time in via a Math expression) for moving grain.
hand-trackerpolymorphicDetect up to two hands in an incoming image using MediaPipe HandLandmarker. Primary output is the hand skeleton as a spline (21 landmarks wired into 21 bones per hand). Aux outputs expose left/right wrist positions as vec2; toggling Show fingers adds per-finger tip vec2s (thumb / index / middle / ring / pinky on each side). Detection is throttled via `detect_fps` and the output is exponentially smoothed so downstream motion stays fluid between detect calls.
image-flow-fieldEstimate the flow of an image: per-pixel edge orientation (smoothed structure tensor) encoded as a field image — tangent direction in RG (velocity-field convention, so Advect Image/Points and Displace consume it directly) and anisotropy/coherence in B (0 = flat region, 1 = strong directed edge). The steering input for painterly nodes (Flow Blur, and the rest of the program as it lands): compute the field once, drive many consumers. `Pre-blur` gates pixel noise out of the gradient; `Smooth` sets the tensor-blur scale — larger values give longer, more coherent stroke directions. The `coherence` aux exposes B as a mask for driving anything (scatter density, thresholds…). Visualize the field by wiring it plus a noise image into Flow Blur. Don't matte or mask a field image — matte the consumer's output.
keyerKeys pixels transparent by luminance (luma key), RGB similarity to a key color (color key), chroma-plane similarity (chroma key — the green-screen mode, brightness-independent), or similarity to a drawn color selection (sample mode — select the node and scrub across the canvas to sample the colors to remove). Softness feathers the matte edge, Spill Suppression desaturates key-color bleed on kept pixels, and Invert swaps keep/key. The matte is also available as a mask aux output.
kuwaharaPainterly smoothing: each pixel pools the least-varying sectors of its neighborhood, flattening texture into paint-like facets while edges stay crisp. `Anisotropic` (default) stretches the facets into strokes along the local flow — steered by the `field` input (Image Flow Field, or any velocity field), or by an internal estimate when unwired — and is the temporally stable choice for video. `Generalized` keeps round isotropic facets. `Radius` is the brush size (cost grows with its square); `Sharpness`/`Hardness` set how crisply the winning facet dominates; `Anisotropy` scales how strongly flow coherence elongates strokes, with `Min coherence` forcing elongation where the field reports none (e.g. plain velocity fields).
lens-flareLens flare: chromatic ghosts + halo ring + anamorphic streak. Outputs the FLARE LAYER ONLY (transparent background) — composite back over the source with a Merge (additive) so you can pre-blur / tint between if you want.
line-artExtract stylized ink lines (XDoG): a soft-thresholded difference-of-Gaussians that sweeps from clean line art (low `Softness`) through charcoal tone (high). With `Flow` on the measurement runs across the image's flow and integrates along it (FDoG), consolidating broken contours into coherent hand-drawn strokes — visibly calmer on video than plain edge detection. Output is ink on transparency, ready to Merge over a Kuwahara / Flow Bilateral base (the painterly and toon stacks). `Size` is the line scale, `Threshold` how strong an edge must be, `Sharpen` the tone contrast. The optional `paper` mask modulates the threshold per-pixel — wire noise for hatching/charcoal texture. A wired universal mask mattes the ink.
liquid-glassApple-style refractive liquid glass over a backdrop. Wire the image behind the glass into the backdrop input; a built-in rounded-rect/superellipse panel (optionally smooth-merged with a second shape) refracts, disperses, and glares over it. Wire an SDF into `shape` for any analytic shape — circles, booleans, smooth-union blobs, or splines via SDF Spline.
mergepolymorphicBlends a base image with one or more layer images. Every image input carries its own mask input underneath — the matte for that layer (multiplies its per-pixel coverage, like a track matte). In AI recipes/edits: size the stack by setting `layers` to [{mode, opacity, maskInvert?}, …] (ids are minted automatically; maskInvert flips a wired mask's coverage), and wire inputs ordinally — layer1, layer2, … (mask1, mask2, … for the mattes) — they resolve to the real per-layer sockets, growing the stack when layerN points past the end.
object-trackerDetect objects in an incoming image using MediaPipe. Emits bounding-box rectangles (spline) and per-detection centers (points). IDs persist across frames via IoU matching.
pixelateMosaic the image into blocks, sampling each block's center. Square or circular cells; aspect stretches the grid for non-square mosaics.
polar-coordsMap an image between rectangular and polar coordinates. Rect ⇒ Polar wraps the source around the center (kaleidoscope / tunnel looks); Polar ⇒ Rect unrolls a circular source into a strip. Center, rotation, and radial scale set the pivot and orientation.
posterizeQuantize the image to a small number of tonal levels for a flat, screen-print / cel-shaded look. Per-channel (rgb) or brightness-only (luma, preserves hue).
reaction-diffusionpolymorphicGray-Scott / FitzHugh-Nagumo reaction-diffusion patterns. Pick a preset, tune step count. Optional seed image sets the initial U/V fields (R → U, G → V); otherwise starts from a central splat.
rgb-curvesTone curves — a combined RGB curve plus individual R / G / B curves.
segment-anythingSegment images locally via Transformers.js. Dots mode: select the node and click the canvas to drop dots on what you want — each dot adds another object (SlimSAM); outputs a cutout + selection mask. Auto modes need no points and output an evolving multicolor segment map: Semantic (SegFormer classes, inherently stable colors), Panoptic (DETR instances, overlap-matched across frames), Auto Grid (SAM point grid, slow but class-agnostic) — set Levels for the segment count, and use the grayscale id-map aux with a Color Ramp for custom palettes. For animated inputs, Bake runs the model over an in/out frame range and caches a mask per frame; Free Bake clears it.
sharpenSharpen an image with one of four kernel shapes. Box/diamond/cross are Laplacian-style (crisp); unsharp uses a Gaussian reference for softer falloff.
stippleRe-renders the input as a field of dots whose size and density follow input darkness. Grid (jittered halftone-ish), Screen (stochastic), Packed (organic relaxed-Poisson), and Packed-Flow (persistent dots with fade-in/out + position lerp for animated inputs) modes share the same edge-noise and colorization layer. Dots are either a flat color or sample the image's color at each dot center (pointillism color transfer); the optional `color` input substitutes a different image for that sampling.
thresholdBinary luminance threshold — pixels brighter than the threshold become white, darker become black. Softness widens the transition into a feathered smoothstep edge; Invert swaps the two sides. Uses Rec. 709 luma weighting.
trailspolymorphicTemporal trails — each echo is a faded copy of an earlier frame (opacity only, no color mix). Primary is the current frame over the echoes; the trail aux is echoes only. Feedback: continuous motion trail. Ring: stepped stop-motion echoes. Velocity: directional motion blur along a vector or UV field. History advances only while the timeline plays.
frameWraps an image in a fixed-size element for Auto Layout. Width and height are in layout units (1/1000 of the canvas's smaller dimension); fit controls how the image fills the rect.