Motion & simulation
Procedural motion with the Wind and Jiggle nodes, guide simulation with the Simulate node, follow-the-scalp evaluation, nHair in Maya, guide caches from other packages, and shot correctives.

There are three ways to animate a groom, from cheapest to most expensive:
- Wind and Jiggle nodes: procedural motion computed per frame, with nothing to cache.
- The Simulate node: dynamics on the guides, identical in every host.
- An external simulation (nHair, Houdini) imported as a guide cache.
On an animated character, also turn on Follow Scalp: the groom is evaluated once on the rest pose and carried by the skin, which makes playback, caches and motion blur much cheaper.
In the app and in Blender
App: add Wind, Jiggle or Simulate with Tab in the Graph Editor. An animated groom shows a timeline at the bottom (play, scrub, loop); Follow turns follow-the-scalp on or off. With a Simulate node the timeline has Simulate, Bake and Clear; while it runs, Simulate reads Cancel. The Groom Tools' Correctives tab holds the shot fixes. nHair and keys on params are Maya's (GroomLab app).
Blender: Wind works. Jiggle and Simulate are not supported yet: Jiggle passes the strands through and Simulate isn't fed the scalp's motion. Follow Scalp is on by default. Correctives are not in Blender yet (Blender).
Procedural motion
Two nodes (Add Node > Motion) animate the groom without simulation or caching. Each frame is computed from the time and the scalp's last few frames, so frames can be evaluated in any order, rendered independently on a farm, and always give the same result.
| Node | Effect | Main parameters |
|---|---|---|
| Wind | Bends strands in a gusting wind field that travels over time. | direction, strength, gust, frequency, speed, turbulence |
| Jiggle | Strands lag behind the head's motion, overshoot when it stops, and settle. | strength, frequency, damping, history |
- Play the timeline to see them.
- Both keep roots and segment lengths, and work on strands or guides.
- Bypassing (B) or deleting either restores the groom exactly.
- Their parameters can be keyed like any other (right-click > Set Key, or S over a field),
for example a wind that picks up or changes direction (
directionis keyed as X, Y, Z). See Animating parameters.
groomlab.add_wind(groom, direction=(1, 0, 0), strength=0.3)
groomlab.add_jiggle(groom, strength=1.0)Looping animation
Turn on loop and set loopStart and loopEnd (in frames) on either node to make a cycle (a game idle, a looping clip):
- Wind repeats over the range: the groom at
loopEndequals the groom atloopStart, with no discontinuity across the seam. Gusts still travel with the wind, spacedspeedtimes the loop length apart. - Jiggle reads the frames before
loopStartfrom the end of the range: animate the head as a cycle over the same frames and the jiggle loops with it. - Render
loopStarttoloopEnd- 1 and play them in a loop.
groomlab.add_wind(groom, strength=0.3, loop=True, loop_start=1, loop_end=49)Simulate the guides
The Simulate node (Add Node > Motion) is GroomLab's hair solver. Place it between the guides and Interpolate: the guides respond to gravity and head motion, air drag and wind, and collide with the scalp and a collision mesh; the strands interpolated from them follow. It runs in Maya, the standalone app, groom files and on the farm, with the same results.
- Playback: playing or scrubbing past the simulated frames steps the simulation forward from the last one; scrubbing back reads the cached frames. Changing a setting, or editing the guides, restarts the simulation from the start frame.
- Simulate, bake, render: Simulate Range (GroomLab > Simulate) fills the frames of the playback range; Bake Simulation writes them to an Alembic guide cache (one per Simulate node, next to the scene or the groom file) that renders, exports and the farm read instead of simulating. A bake made with different settings from the node's current ones is ignored (with a message) and the node simulates.
- Bypass (B) restores the groomed guides; before the start frame the guides are as groomed.
| Parameter | Effect |
|---|---|
stretchStiffness | How strongly segments keep their length (1: no stretch). |
bend, twist | How strongly the guides keep their groomed bends and twist (0: a rope). |
rootStiffness, rootStiffnessProfile | How firmly each part of a guide is held to its groomed shape (rootStiffness, mappable, can be painted per guide), multiplied by the root-to-tip profile: stiff roots, free tips. |
damping, drag | How quickly motion dies out; air drag (also the coupling to the wind). |
mass | Hair mass: drag and other hair move heavier hair less (gravity accelerates all hair equally). |
strength | Fraction of the simulated motion applied, 0-1: paint 0 where guides should stay as groomed. |
gravity, gravityDirection | 980 (cm/s²), straight down. |
groomedUnderGravity | The groomed shape is how the hair rests under gravity at the start frame, so still hair keeps its shape. preload (default): the hair keeps its full weight, and each guide's rest shape is bent just enough to carry it, so it rests in the groomed shape, presses on what it lies on, and falls back with its weight after a fast move (gravity preloading, as in Liu 2022). Soft hair that could not hold all of its weight upright takes what it can and the rest is taken away. weightless: gravity's pull at the start is taken away; only its change as the head tilts or turns over moves the hair. off: gravity pulls on the groomed shape and the hair sags until it hangs. |
windSpeed, windDirection, windGust, windFrequency | A gusting wind the hair is dragged toward (the same gusts as the Wind node). |
inertia | How much of the head's motion the hair feels (lower: less floppy; 0 moves rigidly with the head). |
collideScalp, collisionOffset, friction | Collision with the scalp and the collider input's mesh; friction is the scalp's (a ColliderMesh node's friction sets its own mesh's). |
repulsion, repulsionRadius | Pushes guides apart where they bunch up (off by default). |
volume, volumeCellSize | Volume preservation (off by default): hair packed denser than one cell is pushed apart, so long hair keeps its body. |
substeps, iterations | Accuracy: steps per frame, constraint iterations per step. |
startFrame | The frame at which the simulation starts at rest; start a few frames before the shot so the hair can settle. |
preroll | Frames the hair settles before the start frame, from the rest pose (0: off). It starts at rest in the groomed shape on the scalp's rest pose, with the driver curves as bound; the head and the rig move to the start frame's pose over the first half and hold over the second. A shot that starts far from the rest pose (the head turned, the rig posed) starts with the hair hanging as it would, not stiffly holding the groomed shape. Without a rest pose on the scalp the head holds where it is and the hair settles there. |
cacheMode | live simulates during playback; cached only in Simulate Range (other frames as groomed). |
water, waterLevel | Water (off by default): below the surface, either the plane at waterLevel (world Y) or the mesh on the water input. |
buoyancy, waterDrag | Under water: upward force as a fraction of gravity (above 1 the hair floats up); drag much stronger than in air. |
currentSpeed, currentDirection | A slowly varying current that the hair drifts with under water. |
dryTime, wetWeight, rain | Wetness: seconds to dry after leaving the water; how much heavier and limper wet hair is; rain that wets the hair without applying forces. |
Presets
The Simulate node's Preset button (under its parameters in Maya's Graph Editor; Presets beside its name in the standalone app's parameter panel) sets the motion settings in one click:
- Default: the node's defaults. Hair keeps its groomed shape while still, swings freely and is held only near the root.
- Fur: springy fur that holds its groom (next section).
Both set the same parameters (groomedUnderGravity, bend, twist, damping, drag,
rootStiffness, rootStiffnessProfile, inertia, iterations), so switching between them
leaves nothing behind. Gravity, wind, collisions, water and painted maps are not changed. In
Python: sim.simulate_preset(groom, "fur"), or sim.add_simulate(groom, preset="fur").
Springy fur that holds its groom
Short fur should keep its groomed look when the animal stands still, react when it moves, and spring back after a few quick swings. The Fur preset does this. These are the settings that matter, with the preset's values:
| Setting | Fur | What it does |
|---|---|---|
groomedUnderGravity | weightless | Gravity does not pull the groom out of shape. The groomed shape is taken as how the fur rests under gravity, so only motion moves it. |
bend | 0.8 | How stiff each guide is along its length. This setting has the largest effect: 0.9 is nearly rigid, 0.7 is clearly loose. |
rootStiffnessProfile (with rootStiffness 1) | root 1, middle 0.7, tips 0.35 | How firmly each part of the guide is pulled back to its groomed shape. Holding the whole length, not only the root, keeps the look and makes the fur spring back. |
inertia | 0.8 | How much of the body's motion the fur feels. |
damping | 0.25 | Slows the swinging. Its effect is small next to bend and the profile. |
On a wolf (30 fps, a 90 degree turn in 8 frames, a run, a hard stop), the typical guide's tip moved less than 0.1% of its length while the wolf stood still (86% with the node's defaults, which let the fur hang). During the motion the tips moved about half the guide's length. After the stop they swung two or three times and came to rest within a third of a second.
If the result is not what you want:
- Too stiff (barely moves): lower
bendto 0.7 to 0.75, or lower the profile's middle and tips (0.5 and 0.25), or raiseinertiato 1. - Too floppy (moves far, loses its shape in motion): raise
bendto 0.85, or raise the profile's middle and tips, or lowerinertiato 0.6. - Too wobbly (keeps swinging): raise
bendor the profile's middle and tips;dampingup to 0.5 shortens the swinging a little. - Too dead (stops without any spring): lower
bendto 0.75, or lower the profile's tips. - Sags when the head tilts or turns over:
groomedUnderGravitykeeps the shape for the pose at the start frame; gravity's change as the head tilts still acts. Raise the profile's tips to hold it, or setgroomedUnderGravityto off to let gravity act on the groom fully. - Floats instead of falling back after a fast move: use
groomedUnderGravitypreload, so the fur keeps its weight.
Notes:
- The guides must follow the body. On an animated character, give the groom a rest mesh
(Attribute Editor > Inputs, or
groomlab.set_rest_mesh(groom)). A groom whose guides were saved on an earlier version of the scalp mesh (re-meshed or subdivided since) needs it to bind them to the current mesh. - The Simulate node collides with the scalp and its
colliderinput only. To keep fur off the ground or out of another body part, connect that mesh to thecolliderinput through a ColliderMesh node. A Collide node later in the graph acts on the strands, not on the simulation.
Painted simulation parameters
stretchStiffness, bend, twist, damping, drag, rootStiffness, mass and strength
are mappable, per guide and along each guide (like Yeti's per-guide simulation attributes).
Paint a guide map with the Paint brush (Groom Tools > Paint, on the guides) and assign it to
the param ({"guide": "simMask"}), or use a texture, a color set, an expression, or a field node
connected to the exposed param. The maps are read on the guides fed to the node, every frame.
strength: 0 holds the hair to its groomed shape (it still moves rigidly with its root and the head), 1 fully simulates it, values in between apply that fraction of the simulated motion. Painted along a guide (a per-point layer, or an expression oft), the held part stays and the rest hangs from it: stiff fringe roots, free ends.mass: heavier hair is moved less by wind, air drag and neighboring hair, and keeps swinging longer; along a guide, heavier points move less. Gravity acts on all hair equally.bend,stretchStiffness,rootStiffness: stiffer strands in one area, limper ones in another, a firmer hold at the crown.
With every one of these at a constant value (no maps; mass, strength and rootStiffness at
1), the simulation is identical to an unpainted one.
Volume and friction
Long hair under gravity collapses onto itself, because each guide falls to the same place as its
neighbors. volume (similar to Yeti's density gradient) pushes apart hair packed tighter than
about one volumeCellSize and leaves hair that is already spread out alone. Start with volume
0.3 and a cell size about the spacing you want between guides (1 cm on a head); larger cells give
a fuller, smoother shape.
friction works like real friction: hair pressed hard against a surface grips it, and hair barely
touching it slides. The value is the steepest slope hair rests on without sliding, as a share of a
right angle: 0.3 holds on slopes up to 27 degrees, 0.5 up to 45, and 1 never slides. On the scalp,
the hair slides against the scalp as it moves, so a head turn carries the hair resting on it.
Each collision surface has its own friction: friction is the scalp's (and the default), and a
ColliderMesh node's friction its mesh's (-1 uses the Simulate node's). For example, hair
catches on a wool collar and slides off a leather jacket. In Maya, groomlab.add_collider(groom, mesh, friction=0.8) sets it, and the Attribute Editor's Colliders rows show and edit it.
Water and wet hair
With water on, hair below the surface floats (buoyancy), is slowed (waterDrag) and drifts
with the current; the forces fade in over a thin band at the surface, so hair crossing it does not
jump. The simulation writes a per-point wetness attribute, 0 dry to 1 soaked: it rises
within a quarter of a second under water (or in rain) and decays over dryTime. Other nodes
can read it like any attribute: map a Clump's strength to {"attribute": "wetness"} so wet hair
gathers into locks, and HairColor's tipStrength (with a dark tipColor and a flat
tipProfile) to darken it. Bakes include the wetness, so renders use it too.
In Maya: GroomLab > Simulate > Add Simulate Node, Simulate Range, Bake Simulation, Clear Simulation (the last three also at the top of the Simulate node's settings, in every host). In the standalone app the timeline shows Simulate, Bake and Clear when the graph has a Simulate node, and a strip under the scrubber shows the frames simulated (emerald) and baked (blue); a saved groom references its bakes.
from groomlab import sim
node = sim.add_simulate(groom, bend=0.6, startFrame=-10)
sim.simulate(groom, end=120) # Simulate Range
sim.bake_simulation(groom) # the bake that renders and exports read
sim.invalidate_simulation(groom) # simulate again from the start frameRigged hair: driver curves
Studios pose hero and stylized hair with a hair rig before any simulation: a few controls an animator keys for the big shapes and the silhouette, then a simulation adds the follow-through on top. In GroomLab the rig is a set of driver curves, rigged with whatever the host has (in Maya: joints and a skinCluster, spline IK, wire or blend shapes; in Blender: curve objects with hooks, armatures or plain keys), with guides attached to them, and a DriveGuides node that makes the attached guides follow. Maya and Blender have the same Simulate > Drivers menu; the app and the farm play a groom file's drivers from its driver cache.
- Attach: select guides with the GroomLab select tool and a driver curve, then GroomLab >
Simulate > Drivers > Attach Selected Guides to Curve. The curve is connected, a DriveGuides node
goes right after the Guides node, and the drivers are bound at frame 0 (the pose the groom was made
in). The bind and the attachments are saved with the scene and in
.groomfiles. - Animate: each attached guide, and its children, keeps its place round its driver, in the driver's rotation-minimizing frame, as it swings, bends and stretches. Roots stay on the scalp. Guides attached to nothing stay as groomed; a guide attached to several drivers follows each, the nearest most. The viewport draws the driven guides. No curve yet? Create Driver from Selected Guides makes one down the middle of the selected guides, and Create a Driver per Selected Guide one on each guide, exactly its shape (the guide follows it as if bound to it directly): made from the guides as groomed at the bind frame, the pivot at the root, attached and bound, ready to rig.
- Detach Selected Guides returns guides to their groom; Rebind Drivers at Frame 0 takes the bind pose again after the rig's rest pose changed (the attachments stay).
| Parameter | Effect |
|---|---|
strength | How much the attached guides follow (mappable: paint where hair stays as groomed). |
profile | How much each part follows, root to tip. |
Which hair follows the animation exactly: paint the Simulate node's strength (mappable): 0
holds the hair to its input, the driven shape, and 1 simulates it, so a fringe can stick to the rig
while the rest swings.
Simulation on top: put a Simulate node after the DriveGuides node (Guides, DriveGuides,
Simulate). The solver takes the driven guides as its targets on every frame, so its bend and twist
hold the animated shape and rootStiffness (with its profile) pulls toward it: the animation sets the
pose, the simulation adds the swing.
With Follow Scalp, drivers are taken to the rest pose through the scalp point each was anchored to at the bind, so a driver that only moves with the head drives nothing.
On the farm: export_groom writes the driver curves' animation beside the groom file
(<name>.drivers.abc, the file's driverCache) whenever driver curves are connected, so the CLI,
the procedurals and the app drive the hair (and simulate on top) as Maya does, exactly.
Twist: a curve turned about its own length looks the same, so each driver's transform has a
keyable twist (degrees at its tip, none at its root): key it, or connect a joint's rotateX
to it. The guides round the driver turn with its twist since the bind; the driver cache carries it
to the farm.
import groomlab
groomlab.attach_guides(groom, "hair_ctrl_crv1") # the selected guides
groomlab.attach_guides(groom, "hair_ctrl_crv2", group="bangs") # a whole guide group
groomlab.create_drivers(groom) # a curve down the selected guides
groomlab.create_drivers(groom, group="bangs", per_guide=True) # a curve on each guide
groomlab.detach_guides(groom, guides=[12, 13])
groomlab.bind_drivers(groom, frame=0) # after changing the rig's rest poseFollow the scalp
On an animated head, the groom is normally re-evaluated on every frame on the deformed scalp.
With Follow Scalp on (Attribute Editor > Inputs, followScalp), it is evaluated once on the
rest mesh, and each strand is then transformed to the deformed scalp by its root: a rigid
rotation and translation taken from the root's triangle (its edge and normal), without
stretching. Every strand keeps its rest shape, and only this transform is computed per frame, so
playback, exports and motion blur keys are much cheaper (all keys share the rest evaluation).
- Requires a rest mesh (below). Without one, or on a frame where the scalp is at rest, the result is identical to Follow Scalp off.
- World-space guide data: guide curves, simulated guides and guide caches are positions on the current frame; each is transformed back to rest through its root, so the strands they shape end up where the guides are.
- Evaluated at rest: colliders (Collide), ImportCurves' curves, Wind's direction and gusts, and Noise and other world-space effects are evaluated on the rest groom and then carried, so they rotate with the head instead of staying fixed in the world. Collision against a moving body, or wind blowing one way in world space, will differ; turn Follow Scalp off for those grooms.
- Jiggle responds to head motion as it does without Follow Scalp (the scalp history is transformed into rest space).
- No stretch: a scalp that stretches moves the roots apart, but the strands keep their rest size.
- Exports, Arnold (both render modes) and groom files honor it; the flag is stored in the
.groomfile.
groomlab.set_follow_scalp(groom, True)nHair in Maya
nHair remains available alongside the Simulate node: GroomLab > Simulate > Legacy > Simulate Guides (nHair)... creates nHair curves for the primary guides, with follicles on the scalp. Children follow their simulated parents, so the whole groom moves.
- Presets:
fur,short,long,bouncyandwet. - Bake Simulation to Cache writes the posed guides to Alembic and removes the live simulation, for fast, scrubbable playback.
- Remove Simulation returns to the groom as authored. The authored guides are never modified.
from groomlab import sim
made = sim.create_sim_curves(groom, "primary", preset="long", collide=True, preroll=20)
sim.bake_sim(groom, "shot010.guides.abc", made)Houdini and other packages
Guides simulated in another package drive the groom through a GuideCache node, the same in Maya, Blender and the app (GroomLab > Simulate in each):
- Export Guides for Simulation... writes the guides (every guide the Guides node feeds) to Alembic over the playback
range, in GroomLab's space (Y up, centimeters). Each curve carries its guide ID as a per-curve
strandIdattribute. Maya's progress bar counts the frames; Esc cancels and removes the half-written file. - Simulate the curves in the other package. Keep
strandIdon each curve (a primitive attribute in Houdini), keep the roots pinned, and write the result back to Alembic in the same space. - Load Guide Cache... adds a GuideCache node right after the Guides node (loading again
points the same node at the new file). At each frame it lays each curve on the guide with its
strandId: the guides move, and their groups, painted maps and brushed shapes stay. A curve with another point count is resampled along its length to the guide's.
The node's settings: Path and Object (only the curves under one object), Match By
(id, or order for a cache whose curves lost strandId), Frame Offset (a cache that starts
earlier or later than the shot) and Blend (1 the cache's pose, 0 the guides as groomed; key it
to fade the simulation in). Guides with no curve in the cache keep their pose, and the node's note
says how many were posed. Bypass the node to see the groomed guides.
While a GuideCache or Simulate node moves the guides, the viewport draws them as they move, in amber over the groomed guides (which dim): what the strands follow. Brushes still edit the groomed guides.
# Maya
sim.export_guides(groom, "guides.abc", start=1, end=100) # every guide; or one group: "primary"
sim.add_guide_cache(groom, "sim.abc")# Blender
bpy.ops.groomlab.export_guides_sim(filepath="//guides.abc")
bpy.ops.groomlab.load_guide_cache(filepath="//sim.abc")Older Maya scenes whose groom has a guide cache set (sim.set_guide_cache, the groom's
guideCache attribute) still play it.
Motion blur
Give a groom on a deforming scalp a rest mesh, so the strands match between motion samples
(and turn on Follow Scalp for the cheapest keys). The rest mesh is not affected by the
character's transform or rig: it stores the mesh's own points as they were when it was set.
Instances on the strands are motion blurred with them; turn on the Instance node's pinToRest
so simulated guides that stretch don't slide them along the strands.
Shot fixes
Correctives (Groom Tools > Correctives) are sculpt layers applied on top of the groom. Fix Frame creates one that blends in and out around the current frame, with keyable weights; renders include them.
Fixing a simulation: correctives apply to the groomed guides, before the graph's DriveGuides and Simulate nodes. To sculpt on the simulated hair itself, as studios fix a sim, use Simulate > Sculpt on Simulation (Maya): the Simulate node's frames are baked (unless its bake is current), the guides are posed from the bake and the Simulate node, with the DriveGuides and Simulate nodes feeding it, is bypassed. The guides on screen are then the simulated ones and brushes make shot fixes on top of them; renders, exports and groom files carry both (the farm gives the same hair). Back to Live Simulation turns those nodes on again and clears the guide cache; the correctives stay.
from groomlab import shots
shots.sculpt_on_simulation(groom) # bake, pose the guides from it, bypass the sim
shots.add_layer(groom, frame=1012, fade=6) # a fix keyed around frame 1012; brush it
shots.live_simulation(groom) # simulate againColor patterns
HairColor's params and randomness, the Bands node for banded and tipped fur, the FeatherColor node for feather patterns and iridescence, and the downy base of feathers.
Reference photos
Importing reference photos as image-plane cameras, aligning them to the head mesh in the Photos window, and grooming through them.