Points Along Path

Distribute N points evenly along a path's arc length, each carrying index + pathProgress + rotation (tangent) attributes. The elegant way to do centipedes, trains of shapes, or processions that follow a curve.

Category: Points Menu path: Points > Points Along Path

Ports

Port	Type	Direction	Description
path_in	shape	input	The path to distribute along (uses first path of input)
count_in	scalar	input	Overrides count when connected (always-on port)
offset_in	scalar	input	Overrides offset when connected (always-on port)
out	points	output	Distributed points with path-aware attributes

Parameters

Param	Type	Default	Description
count	scalar	10	Number of points to distribute evenly along the path
offset	scalar	0	Shifts all points along the path together. Keyframe 0→1 for procession / centipede / conveyor animation.
wrap	boolean	true	When offset pushes points past [0, 1], wrap (true) or clamp (false). Closed paths effectively always cycle; wrap controls open-path overflow behavior.
orientTangent	boolean	true	Write per-point rotation attribute from path tangent. CloneToPoints auto-orients each instance to the path.

Output attributes

Every output point carries these, ready for downstream consumption:

Attribute	Type	Description
index	scalar	Positional index 0..count-1 — samples Index-source ramps in PointAttributes
pathProgress	scalar	Normalized 0..1 position along the path (after offset + wrap/clamp applied)
rotation	scalar (radians)	Tangent angle at the sample point (only when orientTangent is on). Consumed natively by CloneToPoints.

How It Works

Distribution is cyclic-even: for N points, progress values are i / N for i in 0..N. This gives N evenly-spaced samples with no double-hitting of path endpoints (progress 0 and 1 are the same point on closed paths).

Sampling uses the same Gauss-Legendre arc-length parameterization as ShapeAlongPath — spacing is exactly uniform by physical length, even on bezier paths with varying curvature.

With wrap = true (default), animating offset from 0 to 1 slides every point along the path by a full length, segments that run off the end reappear at the start. Loops seamlessly.

With wrap = false, offset beyond [0, 1] clamps — points pile up at an endpoint. Use for open-path scenarios where you specifically don't want cyclic behavior.

Usage Examples

Centipede crawling along a curve

EditableShape (hand-drawn curve) → PointsAlongPath (count: 30, offset: keyframed 0→1, wrap: true)
                                                ↓
EditableShape (segment/leg) ───→ CloneToPoints  →  DrawShape → Output

Each of 30 segments sits on the curve with rotation matching the local tangent. Animating offset 0→1 makes the whole procession crawl along the path. CloneToPoints reads the rotation attribute natively so every segment aligns automatically.

Color progression along the chain

PointsAlongPath (count: 50) → PointAttributes (source: Index, target: Color, ramp: red→blue)
                            → CloneToPoints ← SegmentShape
                            → DrawShape

50 segments, colored by position in the chain.

Varying scale / size along the procession

PointsAlongPath → PointAttributes (source: Index, target: Scale, curve: 0→1→0 mountain)
                → CloneToPoints ← BodyShape

Segments grow in size toward the middle of the chain and taper at both ends.

Text along path (compose)

Text → TextToShape → CloneToPoints ← PointsAlongPath(count=glyph_count)
                     (distribution: CycleByAttribute, glyphIndex)

One glyph per point along the path, each rotated to the tangent. A "text on a path" effect, assembled compositionally from primitives.

Static row — disable animation

Set count = 20, offset = 0, animate nothing — just get a static even distribution with per-point rotation/progress. Useful for laying out static elements along a curve without any motion.

Pair with ShapeAttributes (source: Index) for per-path chain styling

Use for chain-of-shapes where each segment has its own visual style — different stroke width per segment, e.g. widening toward the tail.

Tips

• Keyframe offset with Linear interp for constant-speed procession. Smooth/Bezier interp gives acceleration curves.
• wrap=true on open paths makes segments "teleport" from end to start — looks seamless for closed-loop rigs but visibly wraps on literal open curves. Use wrap=false if you want the chain to stop at the end.
• count is keyframeable — animating count 5→50 stages the chain growing in (careful: new points appear at discrete positions, so low counts show visible "snap" of new members joining).
• Pair with CloneToPoints(pivot: FirstPoint) for directional shapes (arrows, rockets, fish) so their tip/head leads the motion.
• For variable spacing, chain through PointAttributes(source: Field) to drive custom scale/position offsets per point.

Related Nodes

• ShapeAlongPath — one shape sliding along a path. PointsAlongPath is "N copies of ShapeAlongPath at different progress values" done efficiently.
• CloneToPoints — the natural downstream consumer. Reads rotation natively.
• PointAttributes — sample ramps by index for per-segment styling.
• EditableShape — hand-drawn path source.
• ResampleShape — similar in spirit (redistributes shape vertices along arc length), but outputs a Shape, not Points. Use PointsAlongPath when you want to drive CloneToPoints; use ResampleShape when you want to modify the path itself.
• TrimPath — pair with PointsAlongPath for a chain that grows from one end.