Shape Along Path

Animate a shape along a path. Keyframe progress 0→1 to slide the shape from the path's start to its end, optionally rotating to follow the tangent.

Category: Shape Ops Menu path: Shape Ops > Shape Along Path

Ports

Port	Type	Direction	Description
shape_in	shape	input	The shape that moves (arrow, rocket, dot, letter, etc.)
path_in	shape	input	The path the shape follows (uses first path of the shape input)
progress_in	scalar	input	Overrides progress via expose channel
out	shape	output	Shape transformed to sit on the path at progress

Parameters

Param	Type	Default	Description
progress	scalar	0	Normalized 0-1 position along the path's total arc length. Keyframeable. Values outside [0, 1] wrap — e.g. progress = 1.5 lands at the midpoint, progress = -0.3 lands at 0.7. progress = 1.0 exactly stays at the end (so a one-shot 0→1 keyframe ends cleanly without snapping back to start). To hard-clamp instead, put a Math (Clamp) node upstream of progress_in.
orientToPath	boolean	true	Rotate the shape to align its reference direction with the path tangent
orientOffset	scalar (degrees)	0	Additional rotation added to the tangent angle. Use +90 if your shape is authored facing up instead of right.
pivot	enum	Center	Which point on the shape sits on the path: Center, Origin, FirstPoint, LastPoint, Custom. Matches CloneToPoints semantics.
pivotOffset	vec2	(0, 0)	Pivot position in source-local pixels (used when pivot is Custom)
delayAttribute	string	""	Optional per-path scalar attribute name. When set, each path of the moving shape is sampled at its OWN progress (global − path.delay), letting a multi-path shape stagger along the followed path. Each path gets per-path AABB pivot so it rotates around its own center. Vertices are duplicated per path under this mode (no PointId sharing). Empty (default) preserves the single-transform behavior.

How It Works

The node walks the first path of path_in, computes per-segment arc lengths via Gauss-Legendre quadrature (exact for linear segments, 5-point accurate for bezier segments), and finds the point where progress × total_arc_length lands.

At that point it evaluates both the position and the tangent direction. The shape is then:

1. Translated so the chosen pivot lands on the sampled position.
2. Rotated by the tangent angle (plus orientOffset), if orientToPath is on. Control points of bezier segments rotate with their anchors so curvature is preserved.

Output keeps the same PointId structure as the source shape — downstream nodes that reference specific vertices (CloneToPoints, PointAttributes Custom attributes, etc.) continue to match.

Pivot choice matters. For symmetric shapes (a circle, a regular polygon), Center is natural. For asymmetric "directional" shapes (an arrow with the tip at vertex 0), FirstPoint puts the tip on the path instead of the AABB midpoint — matching typical intuition.

Shape-level attributes written on output:

• pathProgress (scalar): the wrapped progress value (always in [0, 1]), for downstream consumers that want to know where along the path the shape currently sits.
• pathTangentAngle (scalar, radians): the tangent angle at the sampled position.

Usage Examples

Rocket traveling along a curve

Polygon (triangle) → ShapeAlongPath ← EditableShape (hand-drawn curve)
  progress: keyframed 0 → 1 over 60 frames
  orientToPath: on
  pivot: FirstPoint  (tip of the triangle)
→ DrawShape → Output

Rocket tip leads the motion, body follows, rotation stays aligned with the path.

Dot moving along a circle

Circle (small, radius=5) → ShapeAlongPath ← Circle (large, radius=200)
  progress: keyframed 0 → 1 looped
  orientToPath: off
  pivot: Center
→ DrawShape → Output

Small circle orbits the large circle. Turn orientToPath back on if the moving shape is asymmetric.

Write-on stroke effect

Combine with TrimPath for a classic "shape draws itself" effect:

Polygon → TrimPath (end: keyframed 0 → 1) → ShapeAlongPath ← path
                                              progress: keyframed 0 → 1
                                              (sync the two keyframes)

A shape grows along the path as it moves.

Multiple shapes at different progress values

Animate 5 dots evenly spaced along a curve by using 5 separate ShapeAlongPath nodes at progress 0.0, 0.2, 0.4, 0.6, 0.8 — or use CloneToPoints with a point grid that drives a single ShapeAlongPath per point via expose channels.

Tangent-driven color

Downstream node reads pathTangentAngle attribute and drives color via ShapeAttributes — shape color changes based on which way it's currently facing.

Tips

• Keyframe progress with Smooth/Bezier interp for ease in/out. Linear gives constant speed, which can look robotic.
• Cyclic motion: for closed paths (e.g. Circle), keyframe progress with a Hold interp at frame N to snap back to 0, giving a looping traversal.
• Arc length is reliable: even on a bezier with wildly varying curvature, progress=0.5 is exactly halfway by length, not by control-point parameter. Animation feels uniform.
• Multi-path inputs: uses the first path only. Merge multiple paths with MergeShapes if you want them treated as one continuous chain (though this creates virtual "jumps" between path ends).
• Pair with TextToShape: letters as the shape_in, a curve as the path_in, and progress keyframed — letters travel one at a time. Combine with CloneToPoints (CycleByAttribute: glyphIndex) for per-letter placement at once.

Related Nodes

• TrimPath — draws the path itself progressively. Often paired with ShapeAlongPath.
• CloneToPoints — instances a shape at many points. Use ShapeAlongPath when you want one shape moving along the path, not many shapes at discrete positions.
• EditableShape — the most common path_in source, authored via pen tool.
• ResampleShape — use upstream of the path if it's a polyline and you want smoother motion.
• ShapeAttributes — read the shape-level pathTangentAngle attribute to drive other effects downstream.