Expresso
Beta v1.0.0 coming soonStore, organize, copy, and apply After Effects expressions.
All 90 expressions
▶
Random organic motion around the current value. First number = wiggles/sec, second = amount.
Customize
freq = 2; amount = 30; wiggle(freq, amount)
▶
Wiggle horizontally while keeping the Y value locked. Apply to Position.
freq = 2; amount = 30; x = wiggle(freq, amount)[0]; [x, value[1]]
▶
Wiggle scale evenly on both axes so it doesn't distort. Apply to Scale.
freq = 1.5; amount = 12; s = wiggle(freq, amount)[0]; [s, s]
▶
One stable random value per layer that doesn't flicker every frame. Great for offsets.
min = 0; max = 100; seedRandom(index, true); random(min, max)
▶
A wiggle that loops perfectly every loopTime seconds by cross-blending the wiggle with a time-shifted copy of itself. Apply to any property. freq = wiggles/sec, amp = amount, loopTime = seconds per seamless loop. Uses wiggle's optional 5th time argument.
freq = 1; amp = 60; loopTime = 3; t = time % loopTime; w1 = wiggle(freq, amp, 1, 0.5, t); w2 = wiggle(freq, amp, 1, 0.5, t - loopTime); linear(t, 0, loopTime, w1, w2)
▶
Multi-octave wiggle that feels like a handheld camera (fine detail layered on broad motion). Apply to Position (or a camera/null's Position). freq = base frequency, amp = amount, octaves = layers of detail (3 gives a natural jitter).
freq = 3; amp = 25; octaves = 3; wiggle(freq, amp, octaves, 0.6)
▶
Starts calm and intensifies: the wiggle amplitude eases from 0 to maxAmp over the first rampTime seconds of the layer. Apply to any property. freq = wiggles/sec, maxAmp = final amount, rampTime = seconds to reach full intensity.
freq = 3; maxAmp = 80; rampTime = 2; amp = linear(time, inPoint, inPoint + rampTime, 0, maxAmp); wiggle(freq, amp)
▶
Jumps to a new random value rate times per second and holds it in between, for a digital/glitch feel. Works on any 1D property (Opacity, Rotation, a Slider). rate = jumps/sec, minVal/maxVal = value range. Reseeding by time-step keeps each value steady until the next step.
rate = 4; minVal = 0; maxVal = 100; seedRandom(Math.floor(time * rate), true); random(minVal, maxVal)
▶
Smooth, flowing wander using Perlin noise() instead of wiggle — softer and more organic, never jerky. Apply to Position. freq = speed of drift, amp = pixels of travel. Two separate noise fields drive X and Y so they move independently.
freq = 1; amp = 60; value + [noise([time * freq, 0]), noise([time * freq, 100])] * amp
▶
Averages a property's keyframed values over a short window to remove shake — great for cleaning up jittery imported tracking data or hand-keyed noise. Apply to a keyframed property. width = seconds averaged, samples = how many samples to blend.
width = 0.08; samples = 5; smooth(width, samples)
▶
Spin forever at a constant speed. The number is degrees per second. Apply to Rotation.
speed = 60; time * speed
▶
The current frame as a number — handy as a base for counters.
Math.floor(time * thisComp.frameRate)
▶
Forces any time-based expression to update in discrete steps for a choppy stop-motion look. Prefix any expression with posterizeTime(fps); here 6 = updates per second, followed by a wiggle. Apply to any property.
steps = 6; freq = 8; amount = 40; posterizeTime(steps); wiggle(freq, amount)
▶
Shows the current time as a timecode string using the project's display format (respects frame rate and drop-frame). Apply to Source Text. Swap in timeToTimecode() to force a fixed HH:MM:SS:FF format.
timeToCurrentFormat()
▶
Counts down from a number of seconds and displays MM:SS, stopping at 0. Apply to Source Text. start = seconds to count down from.
start = 60;
function pad(n){ n = Math.floor(n).toString(); while (n.length < 2) n = "0" + n; return n; }
t = Math.max(start - time, 0);
pad(Math.floor(t / 60)) + ":" + pad(t % 60) ▶
Hard on/off blink at a fixed rate. Apply to Opacity. rate = blinks per second (each cycle is one on and one off). Change the 100/0 to blink between other values.
rate = 8; Math.floor(time * rate) % 2 == 0 ? 100 : 0
▶
Lets an animated property play normally, then freezes it on the value it had at freezeTime. Apply to any keyframed/animated property (including Time Remap). freezeTime = seconds (comp time) at which to lock the value.
freezeTime = 2; time > freezeTime ? valueAtTime(freezeTime) : value
▶
Returns how fast this layer is moving in pixels per second (magnitude of Position velocity). Apply to a Slider Control to read it, or use it to drive motion blur, stretch, etc. The layer needs animated Position for a non-zero result.
thisLayer.transform.position.speed
▶
Repeat the keyframed animation forever. Needs at least 2 keyframes.
loopOut()
▶
Play the keyframes forward, then backward, forever.
loopOut("pingpong") ▶
Keep going past the last keyframe at its final speed (no repeat).
loopOut("continue") ▶
Repeat the keyframes but keep advancing each cycle — endless forward progress.
loopOut("offset") ▶
Loop the animation backward before the first keyframe.
loopIn()
▶
Loops only the final segment of a keyframed animation instead of the whole thing. The number counts keyframes back from the last one: 1 = loop the last two keyframes; 0 (or blank) = all keyframes. Needs at least 3 keyframes to differ from a normal loop.
loopOut("cycle", 1) ▶
Loops the keyframes contained in the last N seconds rather than a keyframe count. Here 2 = loop the final 2 seconds of keyframes; 0 = all. Needs at least 2 keyframes.
duration = 2;
loopOutDuration("cycle", duration) ▶
Loops a video or precomp forever. Setup: select the layer, Layer > Time > Enable Time Remapping, keep the two auto-created Time Remap keyframes (or set your own), then apply this to the Time Remap property.
loopOut("cycle") ▶
A value that ramps 0 to 1 and instantly resets, repeating forever — no keyframes. Perfect for driving looping gradients, offsets, or Trim Paths. period = seconds per cycle. Multiply the result to scale it to any range.
period = 2; (time % period) / period
▶
A triangle wave that ramps up then down between lo and hi forever, with no keyframes. Apply to any 1D property (Opacity, Rotation, a Slider). period = seconds for a full up-and-down cycle.
period = 2; lo = 0; hi = 100; half = period / 2; t = time % period; t < half ? linear(t, 0, half, lo, hi) : linear(t, half, period, hi, lo)
▶
Adds a natural springy overshoot after the last keyframe. Tune amp / freq / decay.
amp = 0.08;
freq = 2.5;
decay = 3.0;
n = 0;
if (numKeys > 0){
n = nearestKey(time).index;
if (key(n).time > time) n--;
}
if (n > 0){
t = time - key(n).time;
v = velocityAtTime(key(n).time - 0.001);
value + v * amp * Math.sin(freq * t * 2 * Math.PI) / Math.exp(decay * t);
} else {
value;
} ▶
Smooth back-and-forth wave added to a 1D value (e.g. Rotation). amp = size, freq = speed.
amp = 30; freq = 1; value + amp * Math.sin(time * freq * 2 * Math.PI)
▶
Physically simulated bouncing after the last keyframe: the incoming velocity is reflected and decays through a series of parabolic hops, like a ball hitting the floor. Apply to Position (works 1D or 2D/3D). e = elasticity (0-1), g = gravity (px/sec^2), nMax = max bounces. Needs at least one keyframe that establishes the impact velocity.
e = 0.7;
g = 5000;
nMax = 9;
n = 0;
if (numKeys > 0){
n = nearestKey(time).index;
if (key(n).time > time) n--;
}
if (n > 0){
t = time - key(n).time;
v = -velocityAtTime(key(n).time - 0.001) * e;
vl = length(v);
if (value instanceof Array){
vu = (vl > 0) ? normalize(v) : [0, 0, 0];
} else {
vu = (v < 0) ? -1 : 1;
}
tCur = 0;
segDur = 2 * vl / g;
tNext = segDur;
nb = 1;
while (tNext < t && nb <= nMax){
vl *= e;
segDur *= e;
tCur = tNext;
tNext += segDur;
nb++;
}
if (nb <= nMax){
delta = t - tCur;
value + vu * delta * (vl - g * delta / 2);
} else {
value;
}
} else {
value;
} ▶
A decaying back-and-forth swing that settles to rest, added on top of the current value. Apply to Rotation (great for hanging signs, arms, tails). amp = starting swing in degrees, freq = swings/sec, decay = how quickly it settles. No keyframes needed; starts at the layer's in-point.
amp = 40; freq = 1; decay = 0.8; t = time - inPoint; value + amp * Math.sin(freq * t * 2 * Math.PI) / Math.exp(decay * t)
▶
Self-contained elastic entrance: scale springs from 0 up past the target and wobbles into place at the layer's start — no keyframes. Apply to Scale. target = final scale %, freq = wobble speed (radians/sec), decay = settle rate (higher settles faster).
freq = 18; decay = 6; target = 100; t = Math.max(time - inPoint, 0); s = target * (1 - Math.exp(-decay * t) * Math.cos(freq * t)); [s, s]
▶
Circle the composition center. r = radius, speed = rotations/sec. Apply to Position.
radius = 200; speed = 1; a = time * speed * 2 * Math.PI; [thisComp.width / 2 + Math.cos(a) * radius, thisComp.height / 2 + Math.sin(a) * radius]
▶
Keep the anchor point at the center of the layer's content. Apply to Anchor Point.
r = sourceRectAtTime(time, false); [r.left + r.width / 2, r.top + r.height / 2]
▶
Trail the position of the layer directly above with a time delay. Needs a layer above.
delay = 0.1; thisComp.layer(index - 1).transform.position.valueAtTime(time - delay)
▶
Rotate to face a layer named "Target". Apply to Rotation.
target = thisComp.layer("Target").transform.position;
d = target - transform.position;
radiansToDegrees(Math.atan2(d[1], d[0])) ▶
Pins this 2D layer to the anchor point of a layer named "Target" in composition space, working even if Target is parented, nested, or 3D. Apply to Position.
L = thisComp.layer("Target");
p = L.toComp(L.transform.anchorPoint);
[p[0], p[1]] ▶
Scales a footage/solid layer uniformly so it fits inside the composition (contain, keeping aspect ratio). Apply to Scale. width/height are the layer's source pixel dimensions; use Math.max instead of Math.min to fill/cover instead of fit.
sx = thisComp.width / width * 100; sy = thisComp.height / height * 100; f = Math.min(sx, sy); [f, f]
▶
Plays this layer's own keyframed animation delayed by its position in the layer stack, so duplicated layers cascade. Apply to any keyframed property. d = seconds of delay per layer; layer 1 plays with no delay. Needs at least 2 keyframes.
delay = 0.1; valueAtTime(time - (index - 1) * delay)
▶
Each copy of this layer follows an animated layer named "Master" with a delay that grows by its index, creating a trailing streak. Duplicate this layer several times and apply to Position. d = seconds of delay per copy.
delay = 0.08;
m = thisComp.layer("Master");
m.transform.position.valueAtTime(time - index * delay) ▶
Automatically stretches along the direction of travel and squashes across it, based on vertical speed — the classic cartoon effect. Apply to Scale of a layer with animated Position. maxStretch = max % deformation, soft = speed (px/sec) that produces full stretch.
maxStretch = 30; soft = 3000; v = thisLayer.transform.position.velocity[1]; s = clamp(v / soft, -1, 1) * maxStretch; [100 - s, 100 + s]
▶
Rotates the layer to point in the direction it is moving (an expression-based Auto-Orient along path). Apply to Rotation of a layer with animated Position. If the artwork points up instead of right by default, add 90 to the result.
v = thisLayer.transform.position.velocity; radiansToDegrees(Math.atan2(v[1], v[0]))
▶
Circles the comp center on the horizontal (X-Z) plane so the layer swings toward and away from camera. Requires the layer's 3D switch ON. Apply to Position. radius = orbit size in px, speed = revolutions/sec.
radius = 300; speed = 0.4; a = time * speed * 2 * Math.PI; c = [thisComp.width / 2, thisComp.height / 2, 0]; c + [Math.cos(a) * radius, 0, Math.sin(a) * radius]
▶
Rounds the keyframed Position to the nearest grid cell, giving a stepped, pixel-art / UI feel to otherwise smooth motion. Apply to Position. grid = cell size in pixels.
grid = 50; [Math.round(value[0] / grid) * grid, Math.round(value[1] / grid) * grid]
▶
Arranges duplicated layers into a tidy grid based on each layer's index — duplicate a layer many times and they fill rows and columns automatically. Apply to Position. cols = columns, cellW/cellH = spacing in px.
cols = 5; cellW = 200; cellH = 200; i = index - 1; [(i % cols) * cellW + cellW / 2, Math.floor(i / cols) * cellH + cellH / 2]
▶
Gentle, continuous scale pulse so a static element feels alive. Apply to Scale. amp = pulse size in % (e.g. 6 means 94%-106%), freq = pulses per second.
amp = 6; freq = 0.4; s = 100 + amp * Math.sin(time * freq * 2 * Math.PI); [s, s]
▶
Snap to the exact middle of the composition. Apply to Position.
[thisComp.width / 2, thisComp.height / 2]
▶
Drive this value from a Slider named "Speed" on a "Controls" layer. Adjust the names.
thisComp.layer("Controls").effect("Speed")("Slider") ▶
Returns the pixel distance between the positions of two layers named "A" and "B". Apply to a Slider Control (or to Source Text by adding + ""). Uses length()'s two-point form.
a = thisComp.layer("A").transform.position;
b = thisComp.layer("B").transform.position;
length(a, b) ▶
Returns how many layers are in the composition. Apply to a Slider Control, or to Source Text by adding + "".
thisComp.numLayers
▶
Keeps a layer visually locked to a fixed composition point even when it is parented to a moving/rotating/scaling layer. Apply to Position. Here it holds comp center; change the point as needed. Works whether or not the layer currently has a parent.
p = [thisComp.width / 2, thisComp.height / 2]; hasParent ? parent.fromComp(p) : p
▶
Spreads all layers evenly across the comp horizontally by their stacking index, keeping their own Y. Apply to Position. first/last = left and right x positions to span between. Adapts automatically as you add or remove layers.
first = 100; last = thisComp.width - 100; n = thisComp.numLayers; x = n > 1 ? linear(index, 1, n, first, last) : (first + last) / 2; [x, value[1]]
▶
Sits exactly halfway between two layers named "A" and "B", following them live. Apply to Position (works for 2D or 3D). Great for a label pinned between two moving objects.
a = thisComp.layer("A").transform.position;
b = thisComp.layer("B").transform.position;
(a + b) / 2 ▶
Show the same text as a layer named "Master". Apply to Source Text.
thisComp.layer("Master").text.sourceText ▶
Display the current frame number as text. Apply to Source Text.
Math.floor(time * thisComp.frameRate) + ""
▶
Sizes a shape-layer rectangle to wrap a text layer named "My Text" with padding. Apply to a Rectangle path's Size property. pad = extra pixels around the text. Pair with a Position expression to keep the box centered on the text.
pad = 20;
src = thisComp.layer("My Text");
r = src.sourceRectAtTime(time, false);
[r.width + pad, r.height + pad] ▶
Displays the current composition's name. Handy for shot slates and versioning. Apply to Source Text.
thisComp.name
▶
Displays this layer's own name as its text, so renaming the layer updates the text. Apply to Source Text.
name
▶
Formats a number with thousands separators (e.g. 1,250,000). Setup: add a Slider Control named "Amount" to this layer and animate it. Apply to Source Text.
function addCommas(n){
var s = Math.round(n).toString();
return s.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}
addCommas(effect("Amount")("Slider")) ▶
Shows a number with a fixed digit count, padding with leading zeros (e.g. 007). Setup: add a Slider Control named "Count" to this layer. Apply to Source Text. digits = total width.
digits = 3;
n = Math.round(effect("Count")("Slider")).toString();
while (n.length < digits) n = "0" + n;
n ▶
Types the text out one character at a time starting at the layer's in-point, no keyframes. Apply to Source Text. speed = characters per second. Just type your text normally and the expression handles the reveal.
speed = 12; n = Math.floor((time - inPoint) * speed); value.substring(0, n)
▶
Reveals text left-to-right while un-revealed letters flicker through random characters, like a decoding effect. Apply to Source Text. speed = characters locked per second. Spaces are preserved; edit chars to change the flicker alphabet.
speed = 12;
chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
src = value;
n = (time - inPoint) * speed;
out = "";
for (i = 0; i < src.length; i++){
if (i < n){
out += src.charAt(i);
} else if (src.charAt(i) == " "){
out += " ";
} else {
seedRandom(i + Math.floor(time * 30), true);
out += chars.charAt(Math.floor(random(0, chars.length)));
}
}
out ▶
Displays 0% to 100% as text over the layer's lifetime — instant loader/progress readout with no keyframes. Apply to Source Text. To tie it to a specific span, replace inPoint/outPoint with your own start/end times.
Math.round(linear(time, inPoint, outPoint, 0, 100)) + "%"
▶
Picks one word from a list, stable per layer (duplicates show different words that don't flicker). Apply to Source Text. Edit the words array to your own options.
words = ["Ready", "Set", "Go"]; seedRandom(index, true); words[Math.floor(random(words.length))]
▶
Counts from startVal to endVal with a smooth ease (fast then slowing), no keyframes. Apply to Source Text. dur = seconds to reach the end value. Wrap with a comma formatter if you want thousands separators.
startVal = 0; endVal = 1000; dur = 3; n = ease(time, inPoint, inPoint + dur, startVal, endVal); Math.round(n) + ""
▶
Use a hex code as an After Effects color. Apply to a Color property.
hex = "FF9900"; r = parseInt(hex.substr(0, 2), 16) / 255; g = parseInt(hex.substr(2, 2), 16) / 255; b = parseInt(hex.substr(4, 2), 16) / 255; [r, g, b, 1]
▶
Continuously cycles through the color spectrum over time using HSL. Apply to a Color property. speed = hue turns per second; 1 = full saturation, 0.5 = mid lightness.
speed = 0.2; h = (time * speed) % 1; hslToRgb([h, 1, 0.5, 1])
▶
Takes a base hex color, converts it to HSL, rotates only its hue over time, and converts back to RGB (saturation and lightness stay put). Apply to a Color property. The 0.1 controls hue-shift speed.
speed = 0.1;
base = hexToRgb("E03535");
hsl = rgbToHsl(base);
hsl[0] = (hsl[0] + time * speed) % 1;
hslToRgb(hsl) ▶
Gives each layer one stable random color that doesn't flicker. Apply to a Color property. seedRandom(index, true) fixes the color per layer; duplicate layers get different colors.
seedRandom(index, true); [random(), random(), random(), 1]
▶
Uses After Effects' built-in hexToRgb() (AE 16.0+) to turn a hex code into a color, no manual parsing needed. Accepts "FF9900", "#FF9900" or an 8-digit RGBA hex. Apply to a Color property.
hexToRgb("FF9900") ▶
Smoothly oscillates between two hex colors. Apply to a Color property. c1/c2 = the two colors (hex), speed = full-cycle speed in Hz. Uses built-in hexToRgb() and linear() interpolation across the RGBA arrays.
c1 = hexToRgb("FF3366");
c2 = hexToRgb("33CCFF");
speed = 0.5;
t = (Math.sin(time * speed * 2 * Math.PI) + 1) / 2;
linear(t, 0, 1, c1, c2) ▶
Assigns each layer a stable random color chosen from a fixed palette (no ugly fully-random hues, no flicker). Apply to a Color property. Edit the pal array to your brand colors; duplicate layers spread across the palette.
seedRandom(index, true);
pal = [hexToRgb("E63946"), hexToRgb("F4A261"), hexToRgb("2A9D8F"), hexToRgb("264653")];
pal[Math.floor(random(pal.length))] ▶
Gives each layer a hue stepped by its index, so a stack or grid of duplicates forms a rainbow. Apply to a Color property. step = hue increment per layer (0-1), sat/light = saturation and lightness held constant.
step = 0.08; sat = 0.7; light = 0.55; h = (index * step) % 1; hslToRgb([h, sat, light, 1])
▶
Keep a value between a minimum and maximum.
min = 0; max = 100; clamp(value, min, max)
▶
Map a value from one range to another. Here: 0–100 becomes 0–500.
inMin = 0; inMax = 100; outMin = 0; outMax = 500; linear(value, inMin, inMax, outMin, outMax)
▶
Moves this layer a fixed pixel distance toward a layer named "Target". normalize() builds a length-1 direction vector; 150 = pixels to move. Apply to a 2D Position.
dist = 150;
target = thisComp.layer("Target").transform.position;
dir = normalize(target - transform.position);
value + dir * dist ▶
Offsets Position along an angle by a distance, both driven by sliders. Setup: add two Slider Controls named "Angle" (degrees) and "Distance" (pixels) to this layer. Apply to Position. degreesToRadians converts the angle for the trig functions.
ang = effect("Angle")("Slider");
dist = effect("Distance")("Slider");
r = degreesToRadians(ang);
value + [Math.cos(r), Math.sin(r)] * dist ▶
Links one property to another with linear(): fades this layer from 0 to 100% opacity as it moves from the left edge to the right edge of the comp. Apply to Opacity. No keyframes or setup required.
x = transform.position[0]; linear(x, 0, thisComp.width, 0, 100)
▶
Rounds a 1D property to the nearest increment for a mechanical, ratcheting feel (e.g. Rotation snapping in 45 degree clicks). Apply to any 1D property. step = increment size.
step = 45; Math.round(value / step) * step
▶
Smoothly sweeps a 1D property between lo and hi (absolute values, not added to the property). Apply to Opacity, Rotation, a Slider, etc. freq = full sweeps per second. Unlike a plain sine, output stays exactly within lo..hi.
lo = 0; hi = 100; freq = 1; lo + (hi - lo) * (Math.sin(time * freq * 2 * Math.PI) + 1) / 2
▶
Smoothly animate 0 → 100 over the layer's duration, no keyframes needed.
from = 0; to = 100; ease(time, inPoint, outPoint, from, to)
▶
Eases opacity up at the layer's start and down at its end with no keyframes. Apply to Opacity. fadeIn / fadeOut are the durations in seconds.
fadeIn = 0.5; fadeOut = 0.5; a = ease(time, inPoint, inPoint + fadeIn, 0, 100); b = ease(time, outPoint - fadeOut, outPoint, 100, 0); Math.min(a, b)
▶
Eases a value from 0 to 100 between the first two layer markers. Setup: add at least two markers to this layer (tap * on the numpad while previewing). Apply to any 1D property. Change 0/100 to your target range.
m1 = marker.key(1).time; m2 = marker.key(2).time; ease(time, m1, m2, 0, 100)
▶
Animates a 1D property from `from` to `to` with a classic bouncing landing (Penner easeOutBounce), no keyframes. Apply to any 1D property such as Position[1] via a Slider, Scale, or Opacity. dur = seconds of the move.
dur = 1;
from = 0;
to = 100;
function bounceOut(x){
var n = 7.5625;
var d = 2.75;
if (x < 1 / d){ return n * x * x; }
else if (x < 2 / d){ x -= 1.5 / d; return n * x * x + 0.75; }
else if (x < 2.5 / d){ x -= 2.25 / d; return n * x * x + 0.9375; }
else { x -= 2.625 / d; return n * x * x + 0.984375; }
}
t = clamp((time - inPoint) / dur, 0, 1);
from + (to - from) * bounceOut(t) ▶
Eases a 1D property from `from` to `to`, overshooting slightly past the target then settling back (Penner easeOutBack), no keyframes. Apply to any 1D property. dur = seconds of the move, s = overshoot strength (1.70158 is the standard amount).
dur = 0.8; from = 0; to = 100; s = 1.70158; t = clamp((time - inPoint) / dur, 0, 1) - 1; p = t * t * ((s + 1) * t + s) + 1; from + (to - from) * p
▶
Pulses a layer's scale with the music. Setup: select your audio layer, then Animation > Keyframe Assistant > Convert Audio to Keyframes to create the "Audio Amplitude" layer. Apply to Scale. 100 = base size; the slider value adds on top.
base = 100;
a = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");
s = base + a;
[s, s] ▶
Flashes a layer's opacity in time with the audio. Setup: run Animation > Keyframe Assistant > Convert Audio to Keyframes first (creates the "Audio Amplitude" layer). Apply to Opacity. The 4 multiplier boosts the low slider values; clamp keeps it within 0–100.
boost = 4;
a = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");
clamp(a * boost, 0, 100) ▶
Wiggle whose amount is driven by the music, so it shakes harder on loud beats. Setup: select your audio layer, Animation > Keyframe Assistant > Convert Audio to Keyframes (creates the "Audio Amplitude" layer). Apply to Position or Scale. freq = wiggle speed, mult = sensitivity.
freq = 2;
mult = 1;
a = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");
wiggle(freq, a * mult) ▶
Pushes the layer upward on each beat and settles back. Setup: run Animation > Keyframe Assistant > Convert Audio to Keyframes first (creates the "Audio Amplitude" layer). Apply to Position. mult = how many pixels of lift per unit of amplitude.
mult = 2;
a = thisComp.layer("Audio Amplitude").effect("Both Channels")("Slider");
value - [0, a * mult] No expressions here yet.
✨ Generate with AI
Imagine mode invents playful, unexpected expressions to spark ideas.
Demo preview — in After Effects this calls Claude with your API key.
What's new — v0.3.0
In-app updates & a built-in changelog
- Expresso now notices when a newer version is out and shows an update banner — no more checking the website by hand.
- A What's new changelog is built right in: the v… link at the bottom of the sidebar, or Settings ▸ Updates.
- New Updates section in Settings: turn the launch check on or off, and check on demand.
The real Expresso panel — pick a category, expand a row, or hit ✨ Generate.
Built with
- After Effects
- CEP / Bolt CEP
- React
- TypeScript
A dockable After Effects panel for everything expressions: a 90-expression built-in library, your own saved collection, and one-click copy or apply onto whatever you have selected.
Since v0.2 it also has a built-in AI assistant — describe the motion you want and it writes the expression, or point it at an existing one to explain, improve, or riff on it. Bring your own key (Anthropic, OpenAI, or Gemini); it's stored on your machine and goes nowhere else.
What you get
-
90 expressions, ready to go
A built-in library across 11 categories — wiggle rigs, loops, text counters, physics — each with a plain-English description. One click to copy or apply.
-
Your own library
Save the expressions you actually use, organize them into categories, and carry them between machines with import/export.
-
AI that speaks expressions
Describe what you want and get a working expression — or have one explained, improved, or varied. Works with Anthropic, OpenAI, or Gemini.
-
Your key, your machine
Bring your own AI key. It's stored locally and only ever sent to the provider you chose — nothing passes through anyone else's server.
-
Updates that come to you
The panel checks for new versions and shows what changed, right inside After Effects. Bugs and ideas go straight to the developer from Settings.
Expresso — Changelog
v0.3.1 Jul 13, 2026
Tell me what's broken
Settings ▸ Report a bug / Request a feature now open a feedback form on dexterbrewer.com with the tool and your exact version already filled in — so when something breaks, I get the report with enough detail to reproduce it instead of having to ask you which build you're on.
A broken panel is no longer a blank white rectangle. Expresso's dark theme only ever lived on a div that React draws, so the instant the panel failed to render — for any reason — you were looking at the browser engine's plain white background, with nothing to go on. The theme now sits on the page itself, so a failure looks like a failure and there's something to report.
v0.3.0 Jul 8, 2026
Expresso now keeps itself current from inside After Effects.
In-app update notifications
When a newer version is out, a banner appears at the top of the panel with What's new and Get update — no more checking the website by hand.
Built-in changelog
A "What's new" view is built in — click v… · What's new at the bottom of the sidebar, or open it from Settings.
️ Updates settings
A new Updates section in Settings lets you turn the launch check on/off and check on demand.
v0.2.1 Jul 8, 2026
Expresso v0.2.1 — a fix-up on v0.2.0, verified live in After Effects.
Fixed: the Model picker in Settings
On v0.2.0 the model field wouldn't drop down — you could only type into it. It's now a proper dropdown of the selected provider's models, with a Custom model ID… option if you want to paste an exact/newer id. (The old control relied on an HTML feature that After Effects' built-in browser doesn't render.)
More reliable AI
- Requests now time out after 120s instead of leaving the panel stuck on "Thinking…".
- The output budget is larger and each provider now detects a cut-off response and tells you to try again, instead of failing with a confusing error.
- Refreshed the suggested models (adds Claude Fable 5; OpenAI GPT-5 family; Gemini 2.5).
Under the hood
First unit tests and a CI check on every change — groundwork so future releases stay solid.
v0.2.0 Jul 8, 2026
Expresso v0.2.0 — bring your own AI, tidier sidebar, themed dialogs.
Multiple AI providers
Generate, Explain, Variations, and Improve now run on Anthropic (Claude), OpenAI (GPT), or Google Gemini — pick your provider and paste its key in Settings. Each provider's key is stored separately (switching never wipes one), and the model field is editable, so you can use any model id you like.
Collapsible sidebar sections
The Library, Categories, and Yours sections each collapse and expand on their own now, and the panel remembers how you left them.
Themed delete dialog
Deleting an expression used to pop a plain white system box that ignored the theme. It's now an in-app dialog that matches the rest of the extension (with a proper red Delete button, Enter/Escape, and click-away to cancel). Thanks to the users who reported it.
v0.1.0 Jul 1, 2026
A big feature release — the library is bigger, the panel looks better, and AI now helps with any expression, not just new ones.
v0.0.1 Jul 1, 2026
A dockable After Effects panel that stores, organizes, generates, and applies expressions.