Expressions

Adding an expression to a parameter

Any parameter that supports expressions shows an Expr checkbox and a text field in the parameter panel. Tick the box, type your formula, and press Enter or click away to apply it. A small fx badge marks every parameter currently driven by an expression. Everything is undoable — enabling an expression, editing its text, or turning it off.

You can also pick the expression language per parameter: exprtk (the default) or tcl (see Tcl expressions).

How a parameter decides its value

Every parameter can hold three things at once: a constant value, an animation track, and an expression. Comp resolves them in a strict order:

1. Expression — if enabled and valid, it wins.
2. Animation — if there is no active expression, keyframes drive the value.
3. Constant — the plain value you typed, used when nothing else applies.

This means you can add an expression on top of existing keyframes, and remove it later to get the animation back exactly as it was. If an expression fails — a typo, a deleted node, a divide by zero — the parameter quietly falls back to its animation or constant value and shows a warning in the panel. Your render never breaks because of a bad formula.

Which parameters can have expressions

Two expression languages

The language is chosen per parameter and saved with your project. An expression never silently switches languages: if the Tcl language isn't available in your build, a Tcl expression shows a warning and falls back instead of pretending to work.

Context variables

These values are available in every expression, in both languages:

References to other parameters

Read another parameter on the same node, or on any other node in the graph:

this.opacity                 # own parameter
Exposure1.exposure           # another node's parameter
this.blur_size(t-2)          # sampled 2 frames in the past
Source1.translateX(t+1)      # or 1 frame in the future

• Use this. (lowercase) for the node's own parameters, and NodeName. for any other node.
• Node names are matched exactly, including capitalization.
• Only plain names work in references — nodes or parameters whose names contain spaces or hyphens can't be referenced.
• The (t), (t+N), (t-N) suffixes read the referenced parameter at a shifted frame — handy for lag, echo or anticipation effects.
• References link to the parameter itself: rename the node and your expressions keep working, they're updated for you.
• Circular references (A reads B, B reads A) are detected and reported instead of hanging the render.

ExprTK language reference (default)

Standard math syntax with familiar precedence. Parentheses group, and you can chain as many operations as you like.

Built-in functions

Procedural & sampling helpers

Comp adds its own functions on top of the math set:

For value() and curve(), the first argument must be a plain reference like this.opacity or Source1.gain.

Examples

# pulse a blur over time
this.blur_size * (0.5 + 0.5 * sin(frame / 10))

# match another node's value
Exposure1.exposure * 2

# scale with the comp resolution
comp_width / 1920

# ramp from 0 to 1 over the first 100 frames
clamp((frame - frame_start) / 100.0, 0.0, 1.0)

# procedural handheld shake
Transform2.translateX + 6 * (noise(frame / 8.0) - 0.5)

# switch values at a certain frame
frame < 24 ? this.start_value : this.end_value

# sample another parameter two frames back
value(Source1.translateX, frame - 2)

Tcl expressions (optional language)

If your build includes Tcl support, you can switch a parameter's expression language to tcl. It's a deliberately simple, safe subset of Tcl-style syntax: math, parameter reads and a few lookup commands — no scripting, no file or system access.

• References work the same way: this.param, Node.param, with (t), (t+N), (t-N) offsets.
• All context variables from the table above are available.
• Logic words and, or, not are supported.

Available functions

Lookup commands

Tcl expressions can use bracket commands to look things up:

What Tcl expressions don't allow

• General scripting: no loops, no variables, no running commands, no file or network access.
• Characters like $, { }, quotes and semicolons are not part of the supported syntax.
• Very long or deeply nested expressions are rejected with a warning.

Tcl examples

frame + 1
this.translateX * 0.5
max(0, min(1, this.opacity))
atan2(this.translateY, this.translateX) * 180 / pi
(frame > frame_start) and (frame < frame_end)
Source.translateX(t-2) + 1
[value Source.translateX(t-1)] + [frame]
[metadata lens.focal 50]

When something goes wrong

Expressions can't break your project. If a formula has a problem — a typo, a deleted node, a missing parameter, a divide by zero, or a circular reference — the parameter shows a warning in the panel and falls back to its keyframes or constant value until you fix it. Everything about expressions (text edits, enabling, disabling) is undoable.

Expressions and animation together

Expressions and keyframes are complementary, not competing. A common workflow is to keyframe the broad strokes, then add an expression for fine, procedural motion — like a handheld camera shake on top of an animated position. Turning the expression off returns you to the keys.

Not (yet) supported

• Per-pixel variables (x, y) — expressions drive whole parameters, not individual pixels.
• Convenience aliases from other apps (mix, lerp, smoothstep, …) — on the wishlist.
• Expressions on colors, dropdowns and splines; references that hop through more than one node like A.B.C.