---
title: "Behaviours"
description: "Add motion to a property, link it to another value, and keep the keys you authored editable."
canonical: "https://terminal.lottiefiles.com/docs/behaviours/"
last_updated: 2026-10-29
---

# Behaviours

Add motion to a property, link it to another value, and keep the keys you authored editable.

A behaviour sits on a property and moves it on its own, or follows another value, on top of
the keys you make. A landing can settle with a spring; a spinner can drift; a quiet idle can
oscillate. There is no expression to write.

Behaviours work on a layer's Anchor, Position, Scale, Rotation and Opacity, shape values,
fills, strokes, trim paths, group transforms and named controls. When Position is separated,
X and Y have stacks of their own. Paths take Follow, Loop and Steps; colours also take Near, on a layer or as a
[repeat's field](https://terminal.lottiefiles.com/docs/repeats.md#fields).
Their loops can cycle or ping-pong. Behaviours are kept in files: save a file copy of a Creator
document first.

## Add and edit

You choose properties in the rail (the Properties panel in After Effects or Figma) or the
score (the timeline). Click **more** at the foot of the rail until **Behaviours** appears;
click it again when a block's values are below the visible rows.

Select a layer and use a chip in **Behaviours** in the rail, or **Behaviour › Wiggle** (and the
other kinds) in the command palette. The **On** chips choose Position, Scale, Rotation,
Opacity or Anchor, including properties without keys. Click a rail value or a score row to
choose a shape value or control. The lit property gets the next behaviour; Position is the
default. For a spinner, choose **rotation**, then **+ drift**.

Each behaviour has its kind and property at the top, an **on/off** switch, and **✕** to remove
it. Its values work like the other values in the rail: drag a number, click and type, or click
**◆** to key it at the playhead. Keyed controls get score rows of their own.
Choose Loop's Mode and Side with the labelled chips. The lit chip is the current choice;
**◆** keys a choice as a hold.

The property's own keys are its **base**. Edit them on the score, change a rail value, drag the
layer, or bend its motion path: you change the base and the behaviour follows. **≈** marks a
driven score row, and a faint trace behind its keys shows the motion with its behaviours (for a
path, its centre and size). On the stage, a faint trail shows where a driven Position goes; its
own path stays editable.

![Rotation wiggle controls showing Frequency, Amount and Seed in the rail](https://terminal.lottiefiles.com/docs/assets/shots/animate-wiggle.png)

Watch: [Motion without keys](https://terminal.lottiefiles.com/behaviours/).
For a task, see [Make a bell wiggle](https://terminal.lottiefiles.com/docs/how-to/wiggle-a-bell.md).

## Motion of its own

| Kind | Values | What it does |
|---|---|---|
| **Wiggle** | **Frequency** per second, **Amount**, **Seed** | Smooth random motion around the base. Position and Anchor move independently on each axis. Scale moves uniformly. The same seed gives the same motion. |
| **Oscillate** | **Frequency** per second, **Amount** per axis, **Phase** in degrees | A steady sine wave around the base. Position bobs on Y; Scale pulses uniformly. Key frequency to change its speed continuously. |
| **Drift** | **Speed**, **Speed Y**, **Speed Z** per second, for the dimensions present | Adds speed times the time since the layer's in-point. Position starts moving along X; Rotation starts at 90° per second. |
| **Spring** | **Bounce**, **Settle** in seconds | The move lands with speed, overshoots and settles. Its start ease stays; only the last stretch of its arrival changes. Your keys stay as you made them. A hold or an unchanged value adds nothing. |
| **Loop** | **Mode**, **Side** | Repeats the keys after the last one, before the first, or both, to the layer's ends. Cycle repeats; ping-pong goes back and forth; continue carries on at the end's speed; offset adds the distance travelled each time round. |
| **Steps** | **Steps** per second | Holds the motion below it for a beat, for stop-motion. |

Wiggle starts at 2 per second; Oscillate at 1. Their amounts start at 12 px for Position and
Anchor, 6° for Rotation, 4% for Scale and 10% for Opacity. Spring starts at 0.4 bounce and 0.6 s
settle. Loop starts at cycle, after. Steps starts at 12 per second.

## Follow

Choose **Follow…** in the palette, or **+ follow** in the rail. Then click a property's score
row, a rail value's label, or a layer on the stage. A stage pick uses the same property on
that layer: Position follows Position. Click one cell of a vector value to pick X or Y alone.
**esc** cancels. A refused pick says why and leaves the pick open.

The Follow block names its source. **pick** chooses a different one. Both properties must
be in the same composition. Renaming or reordering layers keeps the link. Copy a source and
its follower together and the copy follows the copied source. Copy only the follower and
it keeps its existing source within that composition. A paste into another composition or
document must include the source too.

- **replace** uses the source's value. **add** adds it to the motion below Follow.
- **multiply** multiplies the motion below Follow by the source. For a percentage property,
  such as Scale, Opacity or trim Start, it divides the source by 100 first. A slider at 50
  therefore halves a Scale with a multiply link.
- **Amount** mixes from the motion below Follow to that result: 0% leaves it alone, 100%
  takes the result fully.
- **Delay** reads the source that many seconds earlier. Give copies increasing delays for
  a stagger, then keep editing the leader's keys.
- Turn **Range map** on to map **From**'s two values to **To**'s two values. **Clamp** keeps
  values outside the From range at the nearest To end.

A single number spreads across the target's values; X follows X and Y follows Y. Colours use
replace and Amount to mix. Paths use replace and Delay only.

Sources update before their followers, including chains. A cycle is refused with its chain
named. Delete a source and the follower keeps playing its last result: its rail block says
the source is gone. Pick another source or remove Follow; undoing the deletion reconnects it.

## Aim and Near

**Aim** points a layer's Rotation at another layer's anchor. Add it, then pick a layer with
the same pick-whip as Follow. **Offset** turns the pointing direction; **Amount** mixes it
with the rotation below Aim. Parents, their scales and rotations are included. A turn through
180° keeps going smoothly. Aim needs a 2-D layer and can't point at itself or its children.

**Near** adds more as another layer comes closer. It's a repeat's field: a repeat's **near**
picks a layer and puts Near on every copy (see [Repeats](https://terminal.lottiefiles.com/docs/repeats.md)). Move a null across a grid
to make a wave of size or opacity. A file with Near on other layers keeps it: it plays, its rows
are in the rail, and **pick** chooses its source again.

- **Inner** gives the full effect; **Outer** gives none. Outer must be larger.
- **smooth** eases the falloff between the radii; **linear** gives a straight ramp.
- **Amount** is per dimension. **add** adds it times the falloff. **multiply** blends from
  no change to that multiplier; percentage properties divide the amount by 100 first.
- On a colour, choose the colour to mix towards. The falloff is the mix amount.

Distance is measured between the layers' anchors, through their parents. Deleting, copying and
reordering the source work as they do for Follow.

## Follow the sound

**Sound** makes a property move with a sound: a logo that thumps on the kick, a bar that rises
with the music. It appears in **Behaviours** in the rail, and as **Behaviour › Sound** in the
palette, once the document has a sound (drop an mp3 or wav on the terminal, or add music).

- **Amount** is how far it moves at the sound's loudest, added to the motion below it: Position
  goes up 40 px, Scale grows 20%, Rotation turns 15°, Opacity adds 50, and a Size or an Anchor
  grows 40 px each way. Key it to make the response grow or fade over the animation.
- **Band** listens to the whole sound, or only its **low**s (a kick, a bass: under 200 Hz),
  **mid**s (voices, most instruments: 200 Hz to 2 kHz) or **high**s (hi-hats, cymbals: over
  2 kHz). A range of your own (see **more**) shows as **custom**.
- **Smooth** is how many seconds it takes to fall back after a hit. It rises at once. The default
  of 0.15 s pulses on each beat; a second or more follows the sound's swell.

**more** shows the rest. Each starts where it changes nothing:

- **Lowest** and **Highest** (Hz) are the range it listens to; the Band chips set them.
- **Equaliser** is the sound's spectrum, from 20 Hz on the left to 20 kHz on the right, a bar
  for each band (a few together where the rail is narrow), faint outside the range. A few of the
  lowest stay dark: they're narrower than the steps a sound is measured in. Click a bar to leave
  those frequencies out (a dot), and again to put them back.
- **Threshold** (%): below it nothing moves; above it, it moves the rest of the way. Raise it to
  leave out the quiet parts and keep the hits.
- **Delay** (frames) moves it later, or earlier when negative, than what's heard.
- **Attack** is how many seconds it takes to rise, as Smooth is how long it takes to fall.
- **Channel**: both ears together (**mono**), or the **left** or **right** alone.
- **Normalise**, on: the sound's loudest in what's listened to moves it the whole Amount. Off: as
  loud as it is, so a sound at half volume moves it half the Amount.

The block names the sound it follows; **next** picks the next one when there are several. Sound
follows the main composition's sounds as they're heard, through their Volume keys, so it goes on
layers there.

Players can't listen, so Sound is baked into keys like any behaviour, again whenever the sound
changes, moves or its Volume does. Until the sound is read, the saved keys play and the rail says
**reading its sound…** (or **can't read its sound**). Steps over Sound holds each hit for a beat
of stop-motion.

## Named controls

The **Controls** row adds a **slider**, **angle**, **point**, **colour** or **checkbox** to the
selected layer. Click its name to rename it. Edit its value as elsewhere in the rail: drag or
type a number, edit a point's two cells, choose a colour, or switch a checkbox on or off.
**◆** keys it; **✕** removes it. Keyed controls get score rows. Controls imported from After
Effects are edited in the same place.

**Add controller** in the palette makes and selects an empty null layer named **Controls**
at the top of the selected layer's composition.
Put an Energy slider there to tune several properties together, or a Brand colour that
several fills follow. A control can carry behaviours too: a gently oscillating slider can
give a whole composition one shared rhythm.

| Control | Values | Initial value |
|---|---|---|
| **slider** | One number, −100,000–100,000 | 0 |
| **angle** | −100,000–100,000° | 0° |
| **point** | X and Y, each −100,000–100,000 px | 0, 0 |
| **colour** | Red, green, blue and opacity through the colour picker | White, fully opaque |
| **checkbox** | Off or on; keyed choices hold until the next key | Off |

Adding a control stores a value; it does not move another property until you connect it with
**Follow…**. Watch: [Expression controls](https://terminal.lottiefiles.com/expression-controls/).

## Stack, compare, remove and bake

Behaviours apply in the order listed. Additive kinds add to what is below them; Follow mixes
its source with what is below it. **Loop and Steps read everything below them at another
time.** Drift then Steps gives a stepped scroll;
Steps then Drift adds a smooth scroll to a stepped base.

Turn one off to compare. **Remove behaviours** in the palette removes the selected layers'
stacks and restores their authored properties exactly. Removing the last behaviour with
**✕** does the same. **Bake behaviours into keys** keeps the result as ordinary editable keys
and drops the behaviours and their bases. Each action is one undo step.

To change the order, remove and add the kinds in the order you want. The copilot can add, set,
explain, remove and bake behaviours too.

## Expressions from After Effects

Opening or pasting a Lottie says how many of its expressions can become behaviours. **Make
expressions editable** in the palette (or the copilot) turns them into behaviours, in one undo
step; the rest stay as they were. It recognises loops, wiggles, time times a speed, links to
properties and controls (and arithmetic on them), and inertial bounces, which become Springs
with the same rhythm.

The behaviours play the expressions as After Effects does, which isn't always as ThorVG played
them: compare the motion before saving.

## Live in dotLottie

Follow, Aim and Near have a **live in dotLottie** chip, off by default. Turn it on when an app
will move the source at runtime. Make the source layer's Position a token: moving that token
then changes the linked layer in ThorVG. A static source with no token gets the same result
from its baked keys.

Use a layer as the runtime knob: links from named controls stay baked, since players can't
change a control's value. Give live source and parent layers unique names. A source or parent
that is itself driven keeps the link baked; the chip says why, and saving or exporting says how many
links kept only their bake.

The stage and video use the baked motion. A dotLottie export carries the opted-in expression
beside those keys, and the dotLottie player (ThorVG) runs it, so an app moving the source moves
the link at runtime. Turn the chip off to export only the bake again.

## Control values

The rail shows only the rows that apply to the behaviour and property. Numbers can be typed,
dragged or keyed with **◆**. Choice rows use hold keys. These are the accepted ranges:

| Behaviour | Rows and values |
|---|---|
| **Wiggle** | **Frequency** 0–60 per second; **Amount** 0–100,000; **Seed** 0–4,294,967,295, whole numbers |
| **Oscillate** | **Frequency** 0–60 per second; **Amount** 0–100,000 per dimension; **Phase** −36,000–36,000° |
| **Drift** | **Speed**, **Speed Y**, **Speed Z** −100,000–100,000 units per second, for the dimensions present |
| **Spring** | **Bounce** 0–1; **Settle** 0.01–30 s |
| **Loop** | **Mode**: **cycle**, **ping-pong**, **continue**, **offset**; **Side**: **after**, **before**, **both** |
| **Steps** | **Steps** 0.1–240 per second |
| **Follow** | **Mode**: **replace**, **add**, **multiply**; **Amount** 0–100%; **Delay** 0–600 s; **Range map** and **Clamp**: **off**, **on**; **From** and **To** −100,000–100,000 |
| **Aim** | **Offset** −36,000–36,000°; **Amount** 0–100% |
| **Near** | **Inner**, **Outer** 0–100,000 px; **Falloff**: **smooth**, **linear**; **Amount** −100,000–100,000 per dimension, or **Colour**; **Mode**: **add**, **multiply** |
| **Sound** | **Amount** −100,000–100,000; **Smooth** 0–5 s; **Lowest**, **Highest** 20–20,000 Hz; **Equaliser** frequency bars; **Threshold** 0–100%; **Delay** −600–600 frames; **Attack** 0–5 s; **Channel**: **mono**, **left**, **right**; **Normalise**: **off**, **on** |

Amounts use the property's units: pixels, degrees or percentages. Follow's **From**, **To**
and **Clamp** appear when **Range map** is on. **Band** offers **all**, **low**, **mid**,
**high**; an edited frequency range shows **custom**. Sound's extra rows appear under **more**.

## In the file

Behaviours travel with your `.lottie`. The property holds the baked motion as keys, which the
dotLottie player (ThorVG) plays at full speed, and keyable After Effects pseudo effects keep the
behaviours and your original keys beside them. Reopening the `.lottie` (or a `.json`) keeps
both, so you can keep editing. Links that should react at runtime can play live instead (see
above); only those write an expression.

The stage plays the same keys.

A property already driven by an expression or a token can't take a behaviour. Bake behaviours
before pasting keys onto a driven layer, making a pattern from it, or ungrouping a precomp that
holds one.