Skip to main content
addEffect puts one of these 91 effects on a node’s stack by kind, with params by name (the defaults below apply to any you leave out) and an optional preset. list_motion_effects (REST: GET /v1/motion/effects) returns the same list.
  • After it is added, each number is a property you can key: field:@e.<effectId>/effect/<param>, e.g. setKeyframes on field:@e.glow1/effect/radius.
  • backdrop: true filters what is drawn beneath the node’s bounds instead of the node (pixel filters only). On a shape filled #00000000 that makes an adjustment layer; with fx.liquidGlass it makes a pane of glass.
  • Points are [x, y] in the node’s pixels, or "center" for its centre.
  • kind: "shader" runs your own SkSL from source: uniform shader image; is the node and half4 main(float2 p) returns each pixel; uniform float2 resolution is bound to the node’s size. Pass other uniforms’ values in uniforms and other nodes as shader inputs in inputs. For random values and noise, call the shader library, which Tella adds to your source and which draws the same on every GPU: tella_hash2d(p) and tella_hash3d(p) (a value in 0..1 per whole-number cell), tella_noise2d(p) and tella_noise3d(p) (smooth value noise in 0..1) and tella_fbm2d(p, octaves) and tella_fbm3d(p, octaves) (fractal noise, 1 to 8 octaves). Don’t hash with fract(sin(...)) or fract(p * k): export GPUs round those differently, which draws lines along the noise grid.

Blur

blur

Gaussian blur. Blurs the node; set one radius to 0 for a directional blur.

boxBlur

Box blur. Box blur: iterations passes of a box radius pixels either side.

lensBlur

Lens blur. Blurs through a polygonal iris, so bright lights bloom into bokeh; with a blur map (a node’s luma as depth) only what lies away from focalDistance blurs.

fx.spinBlur

Spin blur. Radial blur of kind spin about center.

Light

glow

Glow. Glow: what is brighter than threshold is blurred over radius and added.

dropShadow

Drop shadow. A shadow behind the node; with no offset and a light colour, a halo (outer glow).

fx.liquidGlass

Liquid glass. Apple’s Liquid Glass: the node’s box becomes a pane of frosted glass that bends what lies beneath it at its rim. Use it as a backdrop on a #00000000 shape, or set shapeBlur to make a title’s letters (in a transparent or faint colour) glass. Defaults are macOS 26’s clear glass in dark mode; presets give its other styles (regular, control, bright, edgeBleed, deepLens, lens, magnifier, thinBevel, subdued, scrim, each also as …Light). Distances are signed, negative inside the pane. Presets (preset in addEffect and setEffect):
  • clear: macOS’s clear glass (also AppKit variants 2, 3, 7, 8 and 10): a light frost and a strong rim lens. Dark appearance.
  • clearLight: macOS’s clear glass (also AppKit variants 2, 3, 7, 8 and 10): a light frost and a strong rim lens. Light appearance.
  • regular: macOS’s regular glass: more frost and a paler face. Dark appearance.
  • regularLight: macOS’s regular glass: more frost and a paler face. Light appearance.
  • control: A small control’s glass: a shallower lens and a thinner bevel (variant 4). Dark appearance.
  • controlLight: A small control’s glass: a shallower lens and a thinner bevel (variant 4). Light appearance.
  • bright: Glass lifted by a grey screen layer (variant 5). Dark appearance.
  • brightLight: Glass lifted by a grey screen layer (variant 5). Light appearance.
  • edgeBleed: No face colouring, the scene bleeding in from beyond the rim, darkened, with a lit rim (variant 6). Dark appearance.
  • edgeBleedLight: No face colouring, the scene bleeding in from beyond the rim, darkened, with a lit rim (variant 6). Light appearance.
  • deepLens: A deeper, stronger lens (variant 9). Dark appearance.
  • deepLensLight: A deeper, stronger lens (variant 9). Light appearance.
  • lens: Unfrosted glass with a lit rim and an outer lens (variant 11). Dark appearance.
  • lensLight: Unfrosted glass with a lit rim and an outer lens (variant 11). Light appearance.
  • magnifier: A sharp lens and nothing else, like a loupe (variant 19). Dark appearance.
  • magnifierLight: A sharp lens and nothing else, like a loupe (variant 19). Light appearance.
  • thinBevel: Regular glass with a 5 px bevel (variant 20). Dark appearance.
  • thinBevelLight: Regular glass with a 5 px bevel (variant 20). Light appearance.
  • subdued: Regular glass dimmed, as AppKit’s subdued state draws it. Dark appearance.
  • subduedLight: Regular glass dimmed, as AppKit’s subdued state draws it. Light appearance.
  • scrim: Regular glass without its lens, as AppKit’s scrim state draws it. Dark appearance.
  • scrimLight: Regular glass without its lens, as AppKit’s scrim state draws it. Light appearance.

fx.bevelAlpha

Bevel alpha. The alpha edge lit from lightAngle.

Color

curves

Curves. Channel curves: each a list of [x, y] points in 0..1 with increasing x.

lut

LUT. A colour look-up table from the document’s LUT assets.

colorMatrix

Color matrix. A 4×5 colour matrix, row-major (20 numbers), for hue turns and channel mixing.

fx.levels

Levels. Inputs mapped from inputBlack..inputWhite through gamma onto outputBlack..outputWhite.

fx.exposure

Exposure. Exposure in linear light: stops, offset, gamma.

fx.vibrance

Vibrance. Vibrance raises saturation most where it is lowest; saturation raises it evenly.

fx.tint

Tint. Luminance mapped from mapBlackTo to mapWhiteTo.

fx.tritone

Tritone. Luminance mapped through shadows, midtones and highlights.

fx.fill

Fill. Colour replaced by color, alpha kept.

fx.gradientRamp

Gradient ramp. Colour replaced by a ramp from color1 at start to the last of colorCount colours at end, alpha kept: gradient text or shapes. Points are the node’s own pixels, so the ramp moves and scales with it.

fx.posterize

Posterize. Each channel rounded to levels steps.

fx.threshold

Threshold. White where luminance reaches level, black elsewhere.

fx.vignette

Vignette. Darkens (or colours) the edges.

fx.autoLevels

Auto levels. Each channel stretched between its clipped darkest and lightest levels.

fx.autoContrast

Auto contrast. All channels stretched alike between the clipped extremes, keeping colour casts.

fx.autoColor

Auto color. Auto levels, then the midtones (near-neutral with snap, else all) taken to grey.

fx.equalize

Equalize. Levels spread evenly through their distribution: 0 each channel (RGB), 1 brightness, 2 all channels alike (Photoshop style). Color link. The node filled with one colour of another node: its mean, median or clipped extreme.

Key

matteChoker

Matte choker. Softens the alpha, then cuts it at a threshold moved by choke: positive shrinks the matte, negative spreads it.

dilate

Grow. Dilates the node’s pixels by radius.

erode

Shrink. Erodes the node’s pixels by radius.

morphology

Morphology. After Effects’ Minimax: each selected channel becomes its maximum (dilate) or minimum (erode) over radius pixels; open and close run one then the other.

fx.linearColorKey

Color key. Pixels within tolerance of keyColor turn transparent (green screen).

screenKey

Screen key. Keylight-style screen keyer: keys screenColor, despills the edge, and cleans the matte with clip, rollback, shrink/grow and softness.

refineMatte

Refine matte. Refine Soft/Hard Matte and Refine Edge: moves a matte’s edge onto the picture’s edges (hair, motion blur). Reads matte (a node, e.g. a roto or keyed copy) or the node’s own alpha.

snapMatteEdges

Key cleaner. Restores edge detail a hard or compressed key lost, by refining the alpha against the colour.

pathBandKey

Inner/outer key. Keys the node from two paths: opaque inside inner, transparent outside outer, and the colours between unmixed.

fx.colorRange

Color range. Keys colours inside a box in Lab, YUV or RGB (each channel 0..1).

fx.colorDifferenceKey

Color difference key. Two partial mattes, from the key colour’s chroma and from its channel’s excess, combined; view shows each.

fx.channelRangeKey

Extract. Keeps a band of luminance (or one channel).

fx.differenceMatte

Difference matte. Keys what matches another node (a clean plate) out of this one.

fx.spillSuppressor

Spill suppressor. Limits the key colour’s channel to the mean of the other two.

fx.hueSpillSuppressor

Advanced spill suppressor. Removes spill near the key hue, with desaturation and luma correction.

Noise

median

Median. Each channel becomes its median over the square radius pixels either side: removes specks and keeps edges. Exact up to radius 3, a row then column median past it.

selectiveMedian

Selective median. After Effects’ Dust & Scratches: channels more than threshold levels from their median over radius take the median’s value; the rest are kept.

Time

echo

Echo. Copies of the node from other times (motion trails): count copies interval seconds apart (negative looks back).

frameAverage

Wide time. The average of the node over neighbouring frames (CC Wide Time): backward steps before now, now, and forward after; footage shows each step’s frame.

motionBlur

Motion blur. The node averaged over a shutter (After Effects’ CC Force Motion Blur): animation, effects and footage are read at samples times across it.

timeDifference

Time difference. Each pixel compared with the node at another time: mid grey where nothing changed (or black when absolute).

timeDisplacement

Time displacement. Each pixel taken from another time, read from another node’s brightness: white looks ahead, black back, mid grey stays now.

pixelMotionBlur

Pixel motion blur. Blurs each pixel along its own motion since the last frame, estimated from the pixels (optical flow), so footage blurs too.

Generate

repeater

Repeater. Copies of the node, each moved, turned and scaled from the one before.

paint

Paint. Brush, clone and eraser strokes painted on the node. These parameters set its first stroke; addPaintStroke adds more (clone stamps, erasers).

fx.fractalNoise

Fractal noise. Replaces the pixels with animated fractal noise.

fx.grid

Grid. Grid lines over the node.

fx.checkerboard

Checkerboard. Alternate squares in color over the node.

fx.eyedropperFill

Eyedropper fill. The node filled with the average colour of a circle of its own pixels.

paintBucket

Paint bucket. Fills the region connected to point whose pixels are within tolerance of the one there.

Path

trimPath

Trim path. Keeps start..end of a shape’s outline: key end from 0 to 1 to draw a line on.

dashPath

Dashes. Dashes a stroked shape.

cornerPath

Round corners. Rounds a shape’s corners.

discretePath

Roughen edges. Breaks a shape’s outline into jittered segments.

Distort

puppet

Puppet. Bends the node as a rigid mesh inside outline (the node’s box when added; trace a tighter one from what the node draws). Its pins move the mesh: edit them as the effect’s pins field, each with a unique id and its rest point at.

liquify

Liquify. Pushes the node’s pixels with brush strokes (warp, twirl, pucker, bloat, …) inside bounds, the node’s box when added. Edit the strokes as the effect’s strokes field: each has a unique id, a fractional order key (strokes apply in key order) and a path geometry the brush follows, shaped like a paint stroke.

reshape

Reshape. Inside boundary (the node’s box when added), moves what lies along sourceMask onto destinationMask; both start as the same oval, so nothing moves until one is edited.

meshWarp

Mesh warp. Splits the node’s box into a 7 × 7 grid of curved cells; move a vertex with its offset and bend an edge with its handles in the effect’s grid field (row by row from the top left).

bezierWarp

Bezier warp. Bends the node’s box as one patch with four curved edges; its vertices and tangents (topLeftVertex, topLeftTangent, …) start on the box and are edited as the effect’s fields.

fx.waveWarp

Wave warp. A sine wave along angle moves pixels across it; animate phase to make it travel.

fx.turbulentDisplace

Turbulent displace. Pixels taken from up to amount away along fractal noise.

fx.bulge

Bulge. Magnifies (positive height) or pinches the ellipse about center.

fx.twirl

Twirl. Turns pixels about center, easing to none at radius.

fx.mirror

Mirror. Reflects one side of the line through center onto the other.

fx.polarCoordinates

Polar coordinates. Wraps the image around its centre (toPolar 1) or unwraps it.

fx.chromaticAberration

Chromatic aberration. Splits red and blue outward from the centre.

Stylize

fx.brushStrokes

Brush strokes. Repaints the node as brush strokes at angle, each the colour at its middle.

fx.sharpen

Sharpen. Unsharp mask.

fx.mosaic

Mosaic. Blocks of solid colour (pixelate).

fx.addGrain

Add grain. Film grain; it changes every frame.

fx.filmGrain

Film grain. Grain measured from a film stock: fine and clumped, its colours correlated as the stock’s, weighed by tone.

fx.findEdges

Find edges. Dark lines where luminance changes.

Transition

fx.linearWipe

Linear wipe. Wipes the node away from one side; key completion from 0 to 1.

fx.radialWipe

Radial wipe. Wipes the node away clockwise about center.

fx.venetianBlinds

Venetian blinds. Stripes, each wiped away by completion.

fx.gradientWipe

Gradient wipe. Pixels wiped in order of another node’s luminance, darkest first.

EQ & filter

shelfEq

Bass & treble. A low shelf at 200 Hz and a high shelf at 4 kHz.

parametricEq

Parametric EQ. Up to 8 bands, each a peak or a shelf; set band<n>… past the last band to add one.

filter

High-low pass. A second-order low-pass, high-pass, band-pass or notch filter, mixed with the dry sound.

Dynamics

compressor

Compressor. Turns down what rises above the threshold; with key, ducks under another sound (sidechain).

limiter

Limiter. A brickwall limiter: no sample leaves louder than the ceiling.

Echo

delay

Delay. Echoes time seconds apart, each feedback times the one before.

reverb

Reverb. A room’s tail falling 60 dB in time seconds.

Modulation

chorus

Flange & chorus. Delayed copies swept by a slow sine: one short voice with feedback flanges, several longer ones chorus.

vibratoTremolo

Vibrato & tremolo. Vibrato (depth) and tremolo (amplitude) from one oscillator.
Last modified on November 20, 2026