Point clouds. Sources generate position sets; modifiers transform them; `copy-to-points` lets you instance any type per point.
cursor-trail-pointsDrop points along the pointer's path while drawing on the preview — evenly spaced with seeded radial scatter. Feed Loop Weave for the live loop-de-loop demo, or any points consumer. Press mode draws while the mouse button is held; hover drops wherever the pointer moves.
gridEmit an X×Y grid of points. Fit mode spreads the counts across a fixed width/height; Step mode uses an explicit gap between points so the grid grows with the counts.
pointEmit Count points at (x, y). They start stacked at the same location but each has its own index, so per-point nodes (Point Expression, Modulate Points) can spread them apart. With Count 1, combine with Copy to Points to place one instance of an image or spline at a specific location.
tracker-pointpolymorphicTrack N image features across frames. Place tracks on the preview, then step or run the transport in the Parameters tab. Outputs live points (and per-track vec2 sockets) from authored track data — tracking itself runs in the editor, not in compute.
points-on-pathpolymorphicEmit N evenly-spaced positions along a spline. Each point carries a `progress` attribute (0 at the start of the path, 1 at the end; Animate wraps) that Copy to Points can read by name — pick variants, tint, or fade copies by how far along the spline they are. Domain Combined treats every subpath as one concatenated length (points can slide from one onto the next); Per subpath emits Count points on each subpath as its own loop, tagged with that subpath's group. Optionally aligns each point's rotation to the path tangent or normal. Turn on Animate to slide the points along the path with the Offset slider — points that reach the end wrap back to the start (a continuous stream; keyframe Offset or wire a Scene Time / LFO ramp to drive it). Primary output is a `points` value for direct wiring into Copy-to-Points / Set Position / etc. Aux outputs: a UV texture of positions (one pixel per point), a dot visualization image, and a `progress` string (the channel name, for wiring into attribute-name params).
scatter-pointspolymorphicScatter N points across the canvas, optionally weighted by a density input (brighter pixels = more points). Wire an image, or a spline directly — the spline's filled silhouette is the density, sampled without rasterizing to a texture. Deterministic — same seed, same layout.
spline-intersectionsEmit a point at every crossing of the input spline's segments — the 'nodes at intersections' construction-drawing look. Feed the output into Copy to Points to stamp a marker at each crossing. By default only segments from different subpaths are tested (so a cluster of shapes + lines marks line×shape and line×line crossings); enable Self-intersections for self-crossing polylines. The original spline passes through on the aux output so one wire carries both the drawing and its nodes.
spline-to-pointsExtract the input spline's anchor points as a points value — one point per anchor, in subpath order. Each subpath tags its points with its groupIndex (or its subpath index when untagged), so Points to Spline rebuilds the subpaths and per-index nodes split naturally. The original spline passes through on the aux output. For evenly spaced samples along the curve instead of the raw anchors, use Points on Path.
advect-pointsMove points through a velocity field derived from an image — the field is re-sampled at every step, so points follow its curves (unlike Displace's single push). Integrate mode traces N deterministic steps per eval and emits streamline trails (flow-field line art: noise → Advect → trails → Stroke). Accumulate mode keeps persistent positions and advances once per frame — endless drift that responds to an animating field, no Simulation Zone needed. Field modes: angle (luminance → heading), vector (signed RG map), gradient (flow toward bright), contour (orbit level sets).
attribute-blurSmooths a named point channel: each iteration moves every point's value toward its neighborhood mean. Spatial domain averages neighbors within a radius; Index domain averages adjacent points in order (right for path-ordered points). A missing channel passes through unchanged.
attribute-mathComponentwise math on a named point channel: add/subtract/multiply/divide/min/max/power against a constant or a second channel, or remap a range. Writes back in place, or to a new name via Output. A missing channel passes through unchanged.
attribute-transferCopies a named channel from a source point set onto the points by proximity: nearest source point, or a distance-weighted average within a radius (falling back to nearest outside it). The channel lands under the same name; a missing source channel passes the points through unchanged.
behavioral-growthGive points rules and let them move — flocking, schooling, crowds, slime networks. Steering stacks the classic behaviours as weights you can mix: separation, alignment and cohesion for a flock, Seek toward wired Targets (negative values flee), Wander for restlessness, Flow to follow a wired field as an angle map, and Avoid to steer around Obstacles; tag agents with different group indices and turn on Predator/prey to watch a flock split around a chaser. Physarum is the slime-mould network — each agent sniffs the trail ahead and to each side, turns toward the strongest, and deposits its own trail, which diffuses and decays; the Deposit image aux is usually what you actually render. Vicsek is alignment plus angular noise alone, and the noise slider alone takes it from ordered swirls to chaos. Chemotaxis runs and tumbles up a wired field, searching rather than sliding. Integrate re-runs from the seed points every frame (deterministic and scrub-safe, and the Trails aux gives streamline art); Accumulate keeps the agents moving frame to frame as a living system.
copy-to-pointspolymorphicDuplicate an image (or image group), spline, or point at every target point. Each copy respects per-point rotation and scale, anchored at the instance's content center (or canvas center / custom). Per-instance modulation works in every mode: scalar inputs drive every copy uniformly (e.g. audio amplitude on `scale_mul` makes everything pulse), and image inputs are sampled at each copy's position (e.g. noise on `scale_field` gives every copy a different size). Variants — grouped splines / points, or image-group items — land per point via the pick mode: all, image-driven (`pick` input), seeded random, cycle, by the target point's own group, or by a named attribute on the target points. In image mode, named attributes can also tint each copy (Tint attribute, rgb) and fade it (Opacity attribute, alpha). Draw order controls stacking (painter's by-y, shuffled). In spline/point modes, Tag copies chooses the groupIndex the copies carry out: the instance's own tags, the copy's index (so downstream per-group styling — Stroke color/thickness sources, Select by Index — varies per copy), or the target point's group.
drag-pointsGrab individual points with the mouse (or touch) and drag them — offsets persist inside the node, so any points-driven scene becomes hand-arrangeable, in the editor and in exported apps. Grabs the nearest point within the grab radius at press; the gesture owns it until release. Offsets are index-keyed: best on stable point sets (a count change resets them). Reset input clears all offsets.
filter-pointspolymorphicKeep or discard points by predicate. Bbox keeps points inside an XY window; Mask keeps points where the wired image's luminance is ≥ threshold; Index keeps 1 of every N points; Random keeps a stable random subset (hashed on index, so points don't flicker in/out — raising Amount reveals more of the same points, Seed re-rolls the selection). Invert flips which side is kept. Also accepts 3D points (from 3D Scatter Points): bbox becomes a world-space box with Z rows, index/random work identically, mask passes through.
map-attributeDrives built-in point data from a named channel: normalize through In Lo/Hi, shape with a 0–1 curve, then map through Out Lo/Hi and apply as a scale multiplier, a rotation offset (radians), or a position offset. The curve defaults to a linear ramp, so a straight diagonal is the old In→Out remap. A missing channel passes through unchanged.
modulate-pointspolymorphicModulate per-point scale and rotation on a points value. Uniform inputs apply to every point; image fields are sampled at each point's UV and mapped through the configured ranges. Stack to layer modulations; feed the result into Copy to Points (or any consumer that respects per-point attributes).
point-expressionpolymorphicRun a JavaScript expression once per point to compute its new position, scale, and rotation from its own `index` (and `count`, `groupIndex`, current px/py/rot0/sx0/sy0, the `frame`/`t` clock, and wired uniforms). Set `keep=false` to cull a point. Wire a spline into `path` to sample guide curves with pathPos(factor, sub) / pathLen(sub) / pathAngle(...). Deterministic rand(seed) hashes on index for stable per-point randomness; random() varies per frame. attr("name") reads a named point channel (attr("name", c) for a component) and setattr("name", v) writes a float channel — inspect them in the Spreadsheet panel. Target switches the element domain: `spline anchors` runs the code once per anchor instead (read px/py, handle offsets inx0/iny0/outx0/outy0, width0, subpath; write x, y, inx, iny, outx, outy, width, keep). Mark tunables with ch("name", default) (sliders) or pick("name", "optA", "optB") (dropdowns) and hit Sync to turn them into standard controls you can drive. Every ch() channel is also a wireable scalar input socket addressed by its channel name — e.g. with ch("speed", 600) in the expression, wire an LFO or audio level into the `speed` input to drive it. This is the per-element field primitive — the per-point counterpart to the once-per-frame Expression node.
point-labelsDraw a text label on every point, formatted from the point's own data — position (x, y), index, rotation, scale, or group. Pick a field or write a custom token template ({x} {y} {i} {n} {rot} {rad} {sx} {sy} {g}); coordinates read normalized [0,1] or in pixels, with adjustable precision. Self-contained (points → image): each label lands on its point, placed on / above / below / left / right of it with an offset and scale. Style comes from a wired Text node, or the local font/size/color params.
points-to-surfaceMesh a surface around particle clumps: builds a field from a points cloud and traces its outline as a spline (marching squares). `zhu-bridson` is the classic liquid surfacing — flat resting surfaces, calm concave regions; `metaballs` is the blobby lava-lamp merge look. Wire the Matter/Particle Simulator's points output in and liquid gets a skin — the spline coerces straight into any mask/image socket as a filled silhouette, or style it via Rasterize Spline / Stroke (each blob carries a groupIndex for per-blob ramp colors). `radius` sets how far particles reach before merging; `threshold` tightens or fattens the surface; `min blob` culls specks.
points-to-textFormat each point's own data into a string — position (x, y), index, rotation, scale, or group — one label per point. Pick a field or write a custom token template ({x} {y} {i} {n} {rot} {rad} {sx} {sy} {g}); coordinates read normalized [0,1] or in pixels, with adjustable precision. Emits a text_instance: wire it into Copy to Points (text mode, 'by index' pairing) to place each label on its point. Style comes from a wired Text node, or the local font/size/color params.
sample-texture-at-pointsReads a channel of an image at each point's position and writes the value into the chosen attribute (scale or rotation). The sampled [0..1] value remaps linearly to [Lo..Hi] before being combined via Replace / Multiply / Add.
set-named-attributepolymorphicWrites a named channel (a Blender-style attribute) onto points, spline anchors, or spline subpaths: pick a name, a type, and a source — a constant, a 0→1 ramp over element order, a stable per-element random, or an image sampled at each element's position. Channels flow through downstream nodes, show as columns in the Spreadsheet panel, and point channels read back in Point Expression via attr("name"). Reserved names (the built-in x/y/index/rotation/scale/group columns) pass through unchanged.
set-positionpolymorphicTranslate so the input's geometric center lands at (X, Y). Absolute placement — unlike Transform's offset translate, the result is always centered at the target regardless of where the input started.