---
title: Actions Reference
---

### **nil**

Do nothing. Keep the section unchanged at normal speed and pitch.

### **cut**

Remove the section completely from the output.

### **speed**`:float32`

Range: `(0.0, 99999.0)`

Change the playback speed while preserving pitch via time-stretching. 1.0 = unchanged, 2.0 = twice as fast, 0.5 = half speed.

### **varispeed**`:float32`

Range: `[0.2, 100.0]`

Change the playback speed by resampling, so pitch shifts along with it, like analog tape or vinyl. 1.0 = unchanged, 2.0 = twice as fast and an octave higher.

### **ease**`:curve[:duration]`

Set the easing for the animated actions that follow it (until another `ease` overrides it); equivalent to adding `:ease=curve` to each. `curve` is one of `linear`, `in`, `out`, or `inout`.

The optional `duration` (e.g. `2sec` or a bare frame count) is how long the animation takes before holding at its end value; omitted, it spans the whole section. Example: `ease:inout,zoom:1..2`.

### **volume**`:v[..v...]`

Scale the audio volume by val. 1.0 = unchanged, 0.5 = half (-6 dB), 2.0 = double (+6 dB). Animatable: accepts keyframes `a..b..c` interpolated across the section, optionally eased with `:ease=`.

### **deesser**`:intensity[:max[:freq]]`

Range: `each [0.0, 1.0]`

Reduce harsh "s" and "sh" sibilance in the section. Implemented via ffmpeg's `deesser` filter.

Positional args: `intensity` sets how much to de-ess (0.0 = none, 1.0 = maximum), `max` caps the reduction (default 0.5), and `freq` sets the split frequency (default 0.5).

### **duck**`:[amount[:threshold[:attack[:release]]]]`

Autoduck (sidechain): lower this clip's audio wherever the louder audio layers beneath it (higher track indices) are active, e.g. tuck a music/desktop track under a voice track. Cross-track, so it is applied when the audio layers are mixed; a no-op on the bottom-most layer and on single-layer audio.

Positional args: `amount` is the maximum attenuation (0.0 = none, 1.0 = duck to silence, default 0.85), `threshold` the key loudness 0.0..1.0 that engages the duck (default 0.04), and `attack`/`release` the duck-down/recover times in milliseconds (defaults 100 and 500).

### **pitch**`:semitones`

Range: `[-24.0, 24.0]`

Shift the pitch of the section without changing its speed. `12` is one octave up, `-12` one octave down, `0` leaves it unchanged, and fractional values work (`pitch:0.5` is a quarter tone). Implemented by resampling and then time-stretching back with ffmpeg's `asetrate` and `atempo` filters, so large shifts pick up the usual time-stretch artifacts. To change speed and pitch together, use `varispeed` instead.

### **tone**`:midi-note[:waveform]`

Range: `[0.0, 127.0]`

Synthesize a wave at a MIDI note's pitch, as a generator: it stands in for a file in `add:`, adding its own audio layer rather than altering existing audio. `69` is A4 (440 Hz), `60` middle C; each step is a semitone. `waveform` is `sine` (default), `saw`, `square`, or `triangle`; the harmonic-rich ones are band-limited, so they stay clean instead of aliasing at high notes. It has no envelope of its own — chain the animatable `volume` action for fades and decays, e.g. `add:tone:60,volume:1..0:ease=out`. Stack several `add:tone` layers for a chord; the mix sums them. `speed`/`varispeed` only stretch the tone, they do not change its pitch — change the note instead. Examples: `add:tone:69`, `add:tone:36:saw`, `add:tone:48:square,volume:0.4`.

### **invert**

Invert every pixel in the section, producing a photo-negative.

### **hflip**

Flip the section horizontally, mirroring it left to right.

### **vflip**

Flip the section vertically, mirroring it top to bottom.

### **erosion**

Erode the picture by replacing each pixel with the darkest of its 3x3 neighborhood. Bright details shrink and dark regions grow, giving a gritty, eaten-away look. Implemented via ffmpeg's `erosion` filter.

### **zoom**`:v[..v...]`

Range: `(0.0, 100.0]`

Scale the picture about its center by val. 1.0 = no zoom, 2.0 = zoom in 2x, 0.5 = zoom out 2x. Animatable: accepts keyframes `a..b..c` interpolated across the section, optionally eased with `:ease=`.

### **opacity**`:v[..v...]`

Range: `[0.0, 1.0]`

Blend the section against the background. 1.0 = fully opaque, 0.0 = fully transparent. Animatable: accepts keyframes `a..b..c`, optionally eased with `:ease=`.

### **blur**`:v[..v...]`

Range: `[0.0, 1024.0]`

Gaussian-blur the picture by sigma = val. 0.0 = no blur; larger values blur more. Animatable: accepts keyframes `a..b..c`, optionally eased with `:ease=`.

### **brightness**`:v[..v...]`

Range: `[-1.0, 1.0]`

Shift brightness by adding an equal offset to the R, G, and B channels. 0.0 = unchanged, positive brightens, negative darkens. Implemented via ffmpeg's `lutrgb` filter. Animatable: accepts keyframes `a..b..c`, optionally eased with `:ease=`.

### **brighthue**`:snorm16`

Range: `[-1.0, 1.0]`

Shift luma by offsetting the Y channel. 0.0 = unchanged, positive brightens, negative darkens.

### **contrast**`:float32`

Range: `[-2.0, 2.0]`

Scale contrast around mid-gray. 1.0 = unchanged, higher values increase contrast, lower values reduce it. Implemented via ffmpeg's `lutyuv` filter.

### **saturation**`:float32`

Range: `[0.0, 3.0]`

Scale color saturation. 1.0 = unchanged, 0.0 = grayscale, higher values are more vivid. Implemented via ffmpeg's `lutyuv` filter.

### **rotate**`:deg`

Rotate the picture clockwise about its center by a fixed `deg` angle, expanding the frame so nothing is clipped and filling the exposed corners with the background color. Good for aspect flips, e.g. `rotate:90`. For a continuous spin, use `spin` instead.

### **spin**`:deg/rate`

Spin the picture continuously, starting at `deg` and turning at `rate` degrees per second (negative is counter-clockwise), e.g. `spin:0/120`. The picture spins within a constant square that contains every rotation (so it is never clipped); on an overlay the exposed corners are transparent, otherwise they are filled with the background color.

### **drawbox**`:x:y:w:h:color`

Draw a filled rectangle onto the picture. Positional args: `x` and `y` are the top-left corner, `w` and `h` the width and height in pixels, and `color` an RGB color (a name like `red` or a hex value like `#ff0000`). Example: `drawbox:100:100:400:200:red`. As a generator it can take a file's place in `add:`, painting the box on its own overlay layer, e.g. `add:drawbox:100:100:400:200:red`. Implemented via ffmpeg's `drawbox` filter.

### **pos**`:x:y[:scale]`

Place this clip as an overlay when it is composited over a lower video track. `x` and `y` are the top-left corner in canvas pixels; the optional `scale` multiplies the source's native size (default 1.0). Has no effect on the base (bottom) track. Example: `pos:600:300:0.5`. Animatable: each of `x`, `y`, and `scale` accepts a keyframe ramp `a..b..c` interpolated across the section, optionally eased with `:ease=`, e.g. `pos:0..600:300:1..0.5:ease=inout` slides the overlay across while shrinking it.

### **lens**`:k1[:k2]`

Range: `each [-1.0, 1.0]`

Distort the picture like a camera lens. With no arguments, a fun fisheye is applied. Implemented via ffmpeg's `lenscorrection` filter.

Positional args: `k1` is the quadratic correction factor and `k2` the double-quadratic factor. Negative values bulge the image outward (fisheye); positive values pinch it inward (pincushion).

### **colorkey**`:color[:similar:blend]`

Range: `[0.0, 1.0]`

Make a color transparent by matching it in RGB space. Best for flat, synthetic backgrounds (a logo's matte, a screen recording, a gif with one clean color); for real green-/blue-screen camera footage use `chromakey` instead. On the base (bottom) video track there is nothing to reveal, so the matched color is replaced with the timeline background (`-bg`) instead. Positional args: `color` is the key color (a name like `green` or a hex value), `similar` how close a pixel must be to be keyed (default 0.25), and `blend` how soft the edge is (default 0.0). Implemented via ffmpeg's `colorkey` filter.

### **chromakey**`:color[:similar:blend]`

Range: `[0.0, 1.0]`

Make a color transparent by matching it in chroma (YUV) space, tolerating lighting variation, shadows, and soft edges. This is the green-/blue-screen keyer for real camera footage; for flat synthetic backgrounds use `colorkey` instead. On the base (bottom) video track there is nothing to reveal, so the matched color is replaced with the timeline background (`-bg`) instead. Positional args: `color` is the key color (a name like `green` or a hex value), `similar` how close a pixel must be to be keyed (default 0.25), and `blend` how soft the edge is (default 0.0). Implemented via ffmpeg's `chromakey` filter.

### **choke**`:[n]`

Range: `[1.0, 16.0]`

Shrink (choke) the alpha matte left by a `colorkey`/`chromakey` inward by `n` pixels (default 1), cutting off the ring of key-color spill and ragged edge pixels around the subject. Must come after the key in the chain, e.g. `add:fg.mp4,chromakey:green,choke:2`. Only meaningful on overlay tracks (where keying produces alpha); a no-op on the base track. Implemented by eroding only the alpha plane via ffmpeg's `erosion` filter.

### **aberration**`:[h[:v[:edge]]]`

Range: `each [-127.0, 127.0]`

Fake chromatic aberration by shifting the color channels apart, leaving red/cyan fringing for a cheap-lens or glitch look. Implemented via ffmpeg's `rgbashift` filter.

Simple form `aberration[:h[:v[:edge]]]`: split red and blue symmetrically by `h` pixels horizontally (default 5) and `v` pixels vertically (default 0), with green left in place. `edge` is `smear` (extend the border pixel, the default) or `wrap` (wrap around to the far side).

Per-channel form: pass `key=value` pairs drawn from `rh`, `rv`, `gh`, `gv`, `bh`, `bv` (signed pixel shift for each channel/axis, default 0) plus `edge`, e.g. `aberration:rh=8:bh=-8:gv=2:edge=wrap`.

### **loop**

Loop the clip's source back to its start when it runs out of frames, instead of ending. Useful for overlays whose source (e.g. a short gif) is shorter than the section it covers, e.g. `add:logo.gif,loop`.

### **mask**`:x:y:w:h[:radius][:feather][:invert]`

Cut the picture to a rounded-rectangle or ellipse, making everything outside the shape transparent. `x`/`y` are the top-left corner and `w`/`h` the size in pixels. `radius` is the corner radius in pixels: `0` (the default) is a sharp rectangle, a positive value rounds the corners, and `-1` is a true ellipse (the `w`x`h` box's inscribed oval). The optional `feather` softens the edge by that many pixels (0 = hard, the default); append `:invert` to hide the inside instead. Every field also takes a keyword form (`x=`, `y=`, `w=`, `h=`, `radius=`/`r=`, `feather=`), so positional and keyword args can be mixed. On the base (bottom) track there is nothing to reveal, so the masked-out area is filled with the timeline background (`-bg`) instead; on an overlay it reveals the track below. Good for circular/rounded picture-in-picture, vignettes, and crop-to-shape. Example: `add:cam.mp4,pos:900:540:0.3,mask:640:360:300:300:-1:40`.

### **confine**`:[x:y:w:h[:radius][:feather][:invert]]`

Restrict the adjustment effects that follow it (`blur`, `brightness`, `brighthue`, `contrast`, `saturation`, `invert`, `erosion`, `aberration`, `pixelate`) to a rounded-rectangle or ellipse region, leaving the rest of the picture untouched. Stays in effect until the next `confine` changes the region; a bare `confine` with no arguments resets to the full frame. `x`/`y`/`w`/`h` are in pixels; `radius` is the corner radius (`0` sharp rectangle, positive rounds the corners, `-1` a true ellipse); the optional `feather` fades the effect in over that many edge pixels, and `:invert` affects everything outside the region instead. Every field also takes a keyword form (`x=`, `radius=`/`r=`, `feather=`, ...). Geometry effects (zoom, rotate, pos, ...) are unaffected. Example: `confine:400:300:200:80,blur:30` blurs only the box, e.g. to censor a face or plate.

### **pixelate**`:[w[:h]]`

Range: `each [1.0, 1024.0]`

Pixelate the picture into a coarse mosaic of blocks, the classic censoring look. With no argument, uses 16px blocks; `pixelate:n` sets square n×n blocks and `pixelate:w:h` rectangular ones (px). Pair it with `confine` to censor just a face or plate, e.g. `confine:400:300:200:80,pixelate:24`. Implemented via ffmpeg's `pixelize` filter.

### **confetti**`:[count[:gravity][:scheme][:origin][:seed=N][:no-shimmer]]`

Throw colorful confetti over the picture. The whole charge fires in one burst when the section starts, like a party popper, and is not replenished as the pieces fall out of frame, so put the action on a short section where you want the pop. Each piece is a small four-sided chip that arcs over and flutters down, spinning and tumbling in 3D.

Every argument is optional and they may be given in any order, so `confetti:neon:top` and `confetti:top:neon` are the same; bare numbers fill `count` first, then `gravity`.

`count` is 1 to 400 (default 200). `gravity` is 0 to 20 (default 1.4), in frame-heights per second squared so it looks the same at any resolution. It sets how fast the pieces come back rather than how high they go: each is thrown to its own fraction of the way up the frame, and each catches its own amount of air, so they do not come down together. `seed=N` (0 to 65535, default 0) reshuffles the arrangement and changes nothing else, so bump it if you do not like how one landed.

`scheme` is `party` (default), `neon`, `gold`, `duotone`, or `white`. A chip flashes white as it turns edge-on, catching the light like foil; add `no-shimmer` to keep every piece its flat color. `origin` is `sides` (default, two cannons at the bottom corners firing inward), `bottom`, `top` (a shower from just above the frame), or `center`.

Drawn onto the frame, so it is not carried into video-editor exports. As a generator it can take a file's place in `add:`, painting the confetti on its own overlay layer, e.g. `add:confetti:300`. Examples: `confetti`, `confetti:250:3`, `confetti:60:0.8:white:center`.

<h2 id="quick-reference" style="text-decoration:underline;">Quick reference</h2>
<p>Type: A=audio, V=video, *=animatable, G=generator (usable as an <code>add:</code> layer).</p>

| Action | Arguments | Range | Type | Summary |
| --- | --- | --- | --- | --- |
| nil | — | `—` | `AV` | Do nothing. |
| cut | — | `—` | `AV` | Remove the section completely from the output. |
| speed | `float32` | `(0.0, 99999.0)` | `AV` | Change the playback speed while preserving pitch via time-stretching. |
| varispeed | `float32` | `[0.2, 100.0]` | `AV` | Change the playback speed by resampling, so pitch shifts along with it, like analog tape or vinyl. |
| ease | `curve[:duration]` | `—` | `AV` | Set the easing for the animated actions that follow it (until another `ease` overrides it); equivalent to adding `:ease=curve` to each. |
| volume | `v[..v...]` | `—` | `A*` | Scale the audio volume by val. |
| deesser | `intensity[:max[:freq]]` | `each [0.0, 1.0]` | `A` | Reduce harsh "s" and "sh" sibilance in the section. |
| duck | `[amount[:threshold[:attack[:release]]]]` | `—` | `A` | Autoduck (sidechain): lower this clip's audio wherever the louder audio layers beneath it (higher track indices) are active, e.g. |
| pitch | `semitones` | `[-24.0, 24.0]` | `A` | Shift the pitch of the section without changing its speed. |
| tone | `midi-note[:waveform]` | `[0.0, 127.0]` | `AG` | Synthesize a wave at a MIDI note's pitch, as a generator: it stands in for a file in `add:`, adding its own audio layer rather than altering existing audio. |
| invert | — | `—` | `V` | Invert every pixel in the section, producing a photo-negative. |
| hflip | — | `—` | `V` | Flip the section horizontally, mirroring it left to right. |
| vflip | — | `—` | `V` | Flip the section vertically, mirroring it top to bottom. |
| erosion | — | `—` | `V` | Erode the picture by replacing each pixel with the darkest of its 3x3 neighborhood. |
| zoom | `v[..v...]` | `(0.0, 100.0]` | `V*` | Scale the picture about its center by val. |
| opacity | `v[..v...]` | `[0.0, 1.0]` | `V*` | Blend the section against the background. |
| blur | `v[..v...]` | `[0.0, 1024.0]` | `V*` | Gaussian-blur the picture by sigma = val. |
| brightness | `v[..v...]` | `[-1.0, 1.0]` | `V*` | Shift brightness by adding an equal offset to the R, G, and B channels. |
| brighthue | `snorm16` | `[-1.0, 1.0]` | `V` | Shift luma by offsetting the Y channel. |
| contrast | `float32` | `[-2.0, 2.0]` | `V` | Scale contrast around mid-gray. |
| saturation | `float32` | `[0.0, 3.0]` | `V` | Scale color saturation. |
| rotate | `deg` | `—` | `V` | Rotate the picture clockwise about its center by a fixed `deg` angle, expanding the frame so nothing is clipped and filling the exposed corners with the background color. |
| spin | `deg/rate` | `—` | `V` | Spin the picture continuously, starting at `deg` and turning at `rate` degrees per second (negative is counter-clockwise), e.g. |
| drawbox | `x:y:w:h:color` | `—` | `VG` | Draw a filled rectangle onto the picture. |
| pos | `x:y[:scale]` | `—` | `V*` | Place this clip as an overlay when it is composited over a lower video track. |
| lens | `k1[:k2]` | `each [-1.0, 1.0]` | `V` | Distort the picture like a camera lens. |
| colorkey | `color[:similar:blend]` | `[0.0, 1.0]` | `V` | Make a color transparent by matching it in RGB space. |
| chromakey | `color[:similar:blend]` | `[0.0, 1.0]` | `V` | Make a color transparent by matching it in chroma (YUV) space, tolerating lighting variation, shadows, and soft edges. |
| choke | `[n]` | `[1.0, 16.0]` | `V` | Shrink (choke) the alpha matte left by a `colorkey`/`chromakey` inward by `n` pixels (default 1), cutting off the ring of key-color spill and ragged edge pixels around the subject. |
| aberration | `[h[:v[:edge]]]` | `each [-127.0, 127.0]` | `V` | Fake chromatic aberration by shifting the color channels apart, leaving red/cyan fringing for a cheap-lens or glitch look. |
| loop | — | `—` | `V` | Loop the clip's source back to its start when it runs out of frames, instead of ending. |
| mask | `x:y:w:h[:radius][:feather][:invert]` | `—` | `V` | Cut the picture to a rounded-rectangle or ellipse, making everything outside the shape transparent. |
| confine | `[x:y:w:h[:radius][:feather][:invert]]` | `—` | `V` | Restrict the adjustment effects that follow it (`blur`, `brightness`, `brighthue`, `contrast`, `saturation`, `invert`, `erosion`, `aberration`, `pixelate`) to a rounded-rectangle or ellipse region, leaving the rest of the picture untouched. |
| pixelate | `[w[:h]]` | `each [1.0, 1024.0]` | `V` | Pixelate the picture into a coarse mosaic of blocks, the classic censoring look. |
| confetti | `[count[:gravity][:scheme][:origin][:seed=N][:no-shimmer]]` | `—` | `VG` | Throw colorful confetti over the picture. |


---
Version 31.6.1<br>Generated: 2026-09-07.