Live text and string expressions

#String expressions

Where you can type them

• A Vector layer's text field, marked { }. Its placeholder shows the idea: Type text… {0-100} {a, b} {random} {type:HI}.
• Scene copy: the headlines, the CTA text, the disclaimer and text elements in the Layout grid. While you are editing the text you see the raw token; the canvas, playback, stills, HTML export and the rendered video all show the live value.
• The headline strings panel, which has a { } Help button that opens the full reference card.

The seeded tokens ({random}, {rand:} and {pick:}) only work in a Vector layer's text field. In scene copy they print exactly as typed.

The clock: everything is 0 to 1

Every timing number is a fraction of the scene's animation window, which is the scene length minus its Hold. 0 is the start of the scene, 1 is the end of the animation, and the value then stays put through the Hold, so a count finishes on its final number while the viewer reads it. Because nothing is in seconds, an expression re-times itself when you change the scene length. Each linked scene has its own expression and its own window.

Numbers

{A-B} tweens from A to B across the window. {0-100} counts up, {100-3} counts down, and negative numbers work. Decimals follow the more precise end, so {0-9.5} shows one decimal place and two whole numbers show whole numbers.

Add flags after a | to format the number:

• |$ adds a dollar sign and thousands separators: {0-9999|$} passes $5,000 halfway. It is always a dollar sign.
• |%, or a % after the end number: {0-87%} ends on 87%.
• |th gives ordinals: 1st, 2nd, 3rd, 11th, 21st.
• |commas groups thousands: {0-10000|commas} ends on 10,000.
• |step:25 rounds to steps of 25, for a counter that clicks rather than rolls.
• |prefix:+ and |suffix:x add text before or after: {0-50|prefix:+} ends on +50.
• |ease:out (or simply |out, |in, |inout) curves the count. Named curves work too: quad, quart, quint, sine, expo, circ and back, most with in or out in front (|ease:insine), plus inoutquad and inoutsine for both ends. An unknown name counts evenly.
• @0.3-0.9 holds the count to part of the window: {0-100@0.3-0.9} sits at 0 until 0.3, reaches 100 at 0.9 and holds.

Flags are separated by | or by commas, so a prefix or suffix cannot contain a comma. Easing and the @ window work on every token, not just numbers.

Words

{Save, Shop, Win} shows each word for an equal share of the window. Weight a word with a number: {Save:2, Shop:1} shows Save for the first two thirds. {day:Mon,Tue,Wed} is the same idea. A single word in braces is printed as typed unless it has a stagger or delay (see below).

Random but stable

{random} is one digit from 1 to 9, {rand:10-99} is a whole number in that range and {pick:Auckland, Wellington, Christchurch} is one of the words. They are seeded, so they never flicker and they come out the same in every render. On a particle field each particle gets its own value, which is how one layer shows forty different numbers at once.

Type, scramble, clocks and bars

• {type:SALE} types the word on across the window. {type:SALE:0.5} types it in the first half, then holds. Commas inside the text are fine.
• {scramble:LAUNCH} decodes the word from random characters, locking letters from left to right. The random characters avoid look-alikes (no I, O, 0 or 1) and spaces are kept.
• {time:0:30-0:00} is a clock, shown as minutes and seconds. {time:90-0} runs from 1:30 to 0:00. These are displayed values, not real time: the clock runs from 0:30 to 0:00 over the window, whatever the scene length.
• {bar:0-10} is a progress bar ten blocks wide that fills from empty to full. The width is the end number.
• {date:1-31} counts in whole numbers only, which suits dates; add |th for 1st to 31st.

Stagger, order and delay

These matter most on a particle field, where one Vector layer shows the text on many particles.

• Stagger :s0.2 (or |s:0.2). On a field, it spreads the change-over across the particles: with {Save, Shop, Win:s0.2} a fifth of the window passes between the first particle changing word and the last. Every particle still finishes its cycle by the end. On a single object it fades the characters on instead: {WORLD:s0.4}. Add |chars to get the character fade on a field too.
• Order |order:index (the default) runs through the particles front to back. |order:random shuffles them from the scene's seed, so the shuffle is the same in every render.
• Delay :d0.2 (or |d:0.2) waits before the token starts. A word, typed or scrambled token shows nothing until then; a number shows its start value. {0-100:d0.5} holds 0 for half the window, then counts.

They combine: {cat:d0.2:s0.2} waits, then staggers. A stagger is trimmed to whatever the delay leaves, and anything above 1 is clamped to the window.

A particle on a drawn path can use its place on the stroke as its clock instead (Time text to the path), so particles along the line show different values at once.

Gotchas

• A { closed by ) or ] by mistake is still read as a token.
• Anything in braces that is not a token is printed as typed, so Hi {there} stays as it is.
• Braces cannot be nested.
• A comma makes a list of words; a dash between two numbers makes a count.

Worked example

A 9:16 flash sale story, 5 seconds long with a 1 second Hold.

1. Headline: {type:FLASH SALE:0.4}, so the words type on in the first part of the window.
2. Subhead: Up to {0-70%|ease:out} off, so the number rushes up and eases into 70%.
3. CTA: Ends in {time:0:30-0:00} for a ticking countdown feel.
4. A particle layer behind the copy whose text field reads {Save, Shop, Win:s0.5|order:random}, so the words flip across the field in a random ripple.
5. Set Hold to 1 second. Every value lands at 4 seconds and holds for the last second.