Skip to Content
Starlight

Node types

This is the YAML reference for every node type: what it draws or does, and its props (settings). A node is a map with exactly one keyword key. That key picks its kind.

For example, in - text: "GOAL" the keyword is text. The other keys in the map are its props (its settings). A node that draws something (text, image, video, shape, gradient, path) is a layer.

A map with no keyword is an error. So is a map with two keywords.

The full list of node types, with the types that extensions add, comes from the get_project tool. Claude and other AI tools reach it through MCP, the link between Starlight and AI tools (MCP). A node type from an extension cannot go in a scene file yet (What you can register).

All node keywords

These are the only keywords a scene file accepts. Each built-in one has its own section below.

KeywordIts valueWhat it is
textThe wordsType (text)
imageAn asset pathA still picture (image)
cutoutAn asset pathThe old spelling of an image with a cutout effect (image)
videoAn asset pathA movie. It is silent unless you untick muted (video)
audioAn asset pathA sound track. It draws nothing (audio).
shaperect, ellipse or lineA simple shape (shape)
pathA list of subpathsA vector shape (path)
gradientlinear or radialA colour ramp (gradient)
transformA list of nodesPlaces its children (transform)
groupA list of nodesHolds its children, with no transform (group)
cloneA map: { of, count, gap, … }Repeats one source many times (Cloners)
particlesA map: { rate, life, emitter, … }, every key optionalA particle system: sparks, dust, snow (Particles)
useA comp nameA copy of a comp (use)
adjust{}An adjustment layer (adjust)
matteA map: { content, matte, … }Cuts one layer by a shape (matte)
nodeThe name of a node type that an extension addedA custom layer. Its own settings sit beside node: (Extensions)

Common props (every node)

Every node can take these props. They go beside the keyword, never inside its value. This is also true for clone, particles, adjust and matte.

PropMeaning
idA stable identity for the node. You can usually leave it out (IDs are automatic).
clockThe timing that drives the node's animation (clock). See Clocks & animation.
effectsA list of image effects, run on the GPU (the graphics card). See Effects.
spanWhen the layer starts and stops, in scene time: [1s, 3s]. It is the layer's bar on the timeline (Trim a layer). Without a span, the layer draws for the whole scene loop (the length the scene repeats). The rules are below the table.
delayRuns the node and everything inside it later: delay: 400ms. Negative runs it earlier. It wraps around the loop. Moving a bar in the timeline sets it (Delay a layer). A surface binding can take one too, for its use: comp. A scene with a delay is saved as schemaVersion: 7.
bypasstrue switches off what the node adds. A transform or group passes its children through, as if it was not there. A source (a picture, video, shape, gradient, text, path, use, clone, audio) hides. A matte shows its content uncut. An adjust layer changes nothing. Only true counts. In the app, select the node and press b.
blendHow the finished layer mixes with the layers below it (Set a blend mode). The modes: normal · darken: darken multiply color-burn linear-burn · lighten: lighten screen color-dodge add · contrast: overlay soft-light hard-light vivid-light linear-light pin-light hard-mix · inversion: difference exclusion negation · cancellation: subtract divide · component: hue saturation color luminosity. linear-dodge and plus are the same as add.
maskThe old way (scene version 1) to write a mask. Starlight turns it into a matte node when the scene opens.

Span rules.

  • The layer shows from the start time up to the end time. At the end time itself, it is already off.
  • The start must be 0 or more. The end must come after the start.
  • A plain number is milliseconds.
  • A span cannot cross the end of the loop. For that, use two layers, or a gate (The gate).

Blend tips.

  • Use multiply to lay a texture image over type. Use screen or add for light accents.
  • normal, multiply, screen and add cost nothing extra. Every other mode costs one extra render pass (more GPU work).
  • Starlight also accepts other spellings of a mode. Soft Light, softLight and soft_light all mean soft-light.
  • Any other word in blend is an error, and the message lists the modes.

transform — the node that places layers

A transform places the nodes inside it. It is the only node that positions things: a layer has no position of its own.

PropDefaultMeaning
transformrequiredIts children (the keyword value is a list of nodes)
position[0, 0]How far it moves them, in px (pixels): [x, y], { x, y }, or one number
scale1Size factor. One number scales width and height the same. [x, y] or { x, y } scales them apart. A negative number mirrors (flips) them.
rotation0Turn, in degrees. A positive number turns clockwise.
skewX / skewY0Slant, in degrees
opacity10..1 (0 is invisible, 1 is fully visible). A value outside 0..1 is an error.
anchor[0, 0]The pivot point, in local px (inside the transform). This point lands on position. The transform's scale, rotation and skew turn around this point: the fixed ones and the animated ones.
- transform:
    - text: "BOLTS"
      fill: $primary
  position: { x: 170, y: 455 }
  scale: 1.05
  rotation: -16
  skewX: -10
  opacity: 0.85

Transforms nest. An outer transform's move, scale and rotation apply to everything inside it. So one transform with several children is a group that you can place.

  • Animated scale, rotation and skew (from a clock) turn around the anchor too. A transform with no anchor is different: its animation turns around the layer's centre (How tracks combine with the layer).
  • Children draw in list order. The first child is at the back.

text

A text layer draws type. Its keyword value is the words to show.

PropDefaultMeaning
textrequiredThe content (the keyword value). A number becomes text. A line break in the text starts a new line.
font—A family name from brand.fonts. If you leave it out, or the font is missing, Starlight uses a heavy condensed fallback font.
size48Font size, in px. It must be more than 0.
fill#ffffffColour: "#hex" or $token (a named colour from the brand kit or theme: Glossary). Or none: no fill. With a stroke, the word is hollow.
stroke—The colour of an outline around each letter: "#hex" or $token. Starlight draws it on the edge of the letters, under the fill.
strokeWidth1The width of the outline, in px. Half of it is outside the letters and half is inside.
weight—A number such as 800 (100 to 900), or a word such as "bold"
letterSpacing0Space between letters (tracking), in px
alignleftleft · center · right. It also sets which part of the text sits on the transform's position. That is the left edge, the middle or the right edge. Lines of several lines line up the same way.
wrap—A width in px. Lines break at spaces so that each line fits this width. A word that is wider breaks inside the word.
lineHeight—The distance from one baseline to the next, as a multiple of size. 1.25 with size: 40 puts the lines 50 px apart.
maxLines—Show at most this many lines. Starlight cuts the rest.
overflowellipsisWhat a cut text shows. ellipsis ends the last line with …. clip just stops.
anchorYtoptop · baseline. baseline puts the first line's baseline on the transform's position. It is exact for every font.
markupofftrue turns on *italic*, **bold** and ***bold italic*** in the text.
letters—The letters (or words, or lines) come in one after another, each on its own clock (Letters one after another).
- text: "TOUCHDOWN"
  font: knockout-heavy
  size: 204
  fill: $primary
  weight: 800
  letterSpacing: 2
  align: center

A paragraph in a box, for example a review card. The lines wrap at 920 px. The baselines are 1.44 × 38 = 54.7 px apart. The first baseline sits on the transform's position. If the text is longer than 4 lines, the fourth line ends with ….

- text: "easily one of the most beautiful films. *every frame* looks like a page from a storybook"
  font: Inter
  size: 38
  wrap: 920
  lineHeight: 1.44
  maxLines: 4
  anchorY: baseline
  markup: true

Outlined type. The first word is hollow: it has only an outline. The second word is white with a dark edge.

- text: GOAL
  size: 220
  fill: none
  stroke: $team.gold
  strokeWidth: 6
- text: TOUCHDOWN
  size: 160
  fill: "#FFFFFF"
  stroke: $ink
  strokeWidth: 10
  • Without anchorY: baseline, the top of the text sits at the transform's position.
  • Without wrap, text does not wrap by itself. Start a new line with a line break.
  • Italic and bold with a brand font. Each style needs its own font file in brand.fonts, for example Inter-Italic.otf. The key name does not matter: Starlight reads each file and finds the italic and bold files of the same family (Weights and styles of a font). If a file is missing, that part draws in the regular style, and the properties panel tells you which file to add. Starlight never makes a fake slant.
  • Italic and bold with an installed font. Starlight asks the computer for the italic and bold faces of that font.
  • To show a real asterisk in a markup text, write \*.
  • In the properties panel, click N more on the text section to see the layout fields. Set wrap, lineHeight or maxLines to 0 to turn it off.
  • Claude can measure a text with the measure_text tool. It gives the lines, their widths and the baselines, exactly as Starlight draws and exports them.
  • The layout fields need scene format 13. An older Starlight asks you to update before it opens such a scene.
  • Outlines. You do not need an SVG for outlined type. The fill is on top of the outline, so with a fill only the outer half of the outline shows. For a 5 px edge, set strokeWidth: 10. The corners of the outline are round, so sharp corners do not make spikes.
  • The letters stay where they are when you add an outline. The outline goes out from the edges of the letters. The text's box grows by half the stroke width on each side.
  • In the properties panel, the outline rows are stroke, strokeWidth and hollow (no fill). If the text has no outline, click N more to see them.
  • The outline fields need scene format 14. An older Starlight asks you to update before it opens such a scene.
  • font also accepts the name of a font installed on this computer. Another computer may not have it, so use a brand font when you can.
  • For fonts and the fallback chain, see Fonts and the fallback chain and Brand fonts.

Letters one after another

Add letters: to a text to bring its letters in one after another. Each letter plays its own copy of a clock, and each one starts a little later than the one before. You do not need a text layer for each letter.

A player's name, 2 frames for each letter at 60 fps. Each letter fades in and lands with a small bounce. The newest letter is orange and cools to the text's colour.

- text: TAYLOR
  font: anton
  size: 520
  fill: $ink
  letters:
    stagger: 33ms              # each letter starts 33 ms after the one before
    clock:
      period: 200ms             # each letter lands in 12 frames
      mode: once
      tracks:
        opacity: [0, 1, 1]
        scale: [{ phase: 0, value: 0.4, ease: overshoot }, { phase: 1, value: 1 }]
        fill: [{ phase: 0, value: "#FF5A1F", ease: hold }, { phase: 0.2, value: "#FF5A1F" }, { phase: 1, value: $ink }]
PropDefaultMeaning
byletterletter · word · line. What comes in one at a time. A letter with an accent, or an emoji, is one letter.
stagger0A duration, for example 33ms: how long after one letter the next one starts. At 60 fps, one frame is 16.7 ms.
orderforwardforward (first to last) · reverse (last to first) · center (the middle first, then outward) · edges (both ends first, then inward) · random (a mixed order)
clock—Each letter's own clock, written like a layer's clock: period, mode (or use: a named clock) and tracks. Tracks can move a letter (x, y), scale it, turn it (rotate), skew it, fade it (opacity) and change its colour (fill).
  • Each letter moves from its own place. scale and rotate turn around the middle of the letter, on the line the letter sits on (its baseline).
  • Letter number k in the order starts k × stagger after the first one. This is how a clone's stagger works (Repeat a source).
  • With mode: once, a letter shows its first keyframe until it starts, and its last keyframe after it ends. So the word stays still at the end.
  • The last letter ends at period + (letters − 1) × stagger. In the example: 200 ms + 5 × 33 ms = 365 ms.
  • When every letter is at rest, the text looks exactly as it does without letters:. The space between letters (kerning), align, letterSpacing, wrap and the outline do not change.
  • Spaces are not letters. They take no time.
  • random is a fixed order. It is the same each time the scene plays, and on every computer.
  • A fill list in the tracks gives each letter its own colour over time, in place of the text's fill. The outline keeps the text's stroke.
  • The text's own clock still moves the whole text. A gate or a drive goes there, not in letters.
  • Each letter is its own picture on the graphics card. This is fine for names and titles. A long paragraph, letter by letter, makes a lot of pictures.
  • In the properties panel, the text section has letters by, order and stagger ms. If the text has no letters, click N more to see them. A note shows how many letters there are and when the last one starts. Write the letters' clock in YAML, or ask Claude.
  • The timeline shows the text's own clock and colours. It does not show a lane for each letter.
  • Claude's measure_text tool tells you how many letters, words and lines a text has.
  • letters needs scene format 15. An older Starlight asks you to update before it opens such a scene.

image and cutout

An image layer draws a still picture. Its keyword value is the asset path (where the file is in the project).

- image: assets/logo.svg           # the asset path IS the keyword value
- image: assets/players/jane.jpg
  effects:
    - cutout: {}                     # the subject, background removed
  • An image can be png, jpg, svg, webp or gif. Starlight converts other still formats when you import them.
  • An image draws at its own pixel size. Its top-left corner is at the transform's position.
  • An SVG stays sharp and smooth at every size. Starlight draws it again at the size the surface shows it, bigger or smaller. It does this in small steps (about 1.4 times apart), so the edges have no stair steps. You do not need to make a PNG from your SVG.
  • When an SVG needs a new step, the canvas shows the old picture for a moment, then the new one. The layer does not move or change size.
  • A PNG or JPG that you scale down also has smooth edges. Starlight keeps smaller copies of it on the graphics card.
  • An export and a still wait for the sharp step, so every frame is sharp.
  • This also works for a clone of an SVG and for an SVG that is a mask. A very large scale stops at the biggest picture your graphics card can hold.
  • The cutout effect removes the photo's background. A Mac makes the cut-out with macOS Vision.
  • Starlight saves the result in the project, in assets/.cutouts/, so every computer shows it, Windows too (Cut a subject out of a photo).
  • Where Vision is not available (for example on Windows), the original image draws instead.
  • Because cutout is an effect, one photo can do two jobs. Without it, the photo is a full background. With it, the photo is a cut-out subject.
  • To compare, select the effect's chip in the node graph and press b. This turns the cutout off and on (Turn one effect off).
  • The old cutout: <path> keyword still opens. Starlight saves it back as an image with a cutout effect.
  • A missing file, or one Starlight cannot read, draws as one white pixel at the layer's corner. You can hardly see it. The line at the bottom left of the canvas names the file: missing media: … or could not load: …. Check the path (Find missing media).

video

A video layer plays a movie file. On the timeline its bar is called a clip. A new video is muted. Set muted: false to play the clip's own sound. For a sound with its own volume, use an audio layer.

PropDefaultMeaning
videorequiredAsset path (mp4, webm, mov, m4v, ogv)
looptruefalse stops on the video's last frame and holds it
offset0Where the video sits in time. At time 0 on the transport (see below), the layer shows this time of the video. 2s starts 2 s into the video. -1s starts the video one second late. Until then it shows its first frame. When you slip the clip on the timeline (slide the video inside its bar), the app writes this value (Slip a clip). A scene that uses it is schemaVersion: 5.
markers—Layer markers, at times in the video (Mark a frame in a video). They move with the video when you slip it.
mutedtruetrue keeps the clip silent. false plays the clip's own sound through the 🔊 monitor, and mixes it into exports at full volume (only when the file has sound). The sound plays once per clip, even when several layers show the same file. It follows the clip's loop and offset. A bypassed layer makes no sound. For music, an audio layer gives you volume and more.

Video follows the scene transport. The transport is the scene's play position in time. Play, pause and scrub (drag the playhead) change it.

  • When you pause, scrub, step or switch scenes, each video shows the frame that an export would render at that time.
  • A video does not restart when the scene loop restarts. Like audio, it follows the transport's running time. That time keeps counting across loops.
  • A looping video restarts at the end of its own length. So a video longer than the loop keeps playing across loop restarts.
  • A video exactly as long as the loop shows the same frame on every pass.
  • A span only sets when the layer draws. The offset moves the video in time.
  • Starlight uses one decoder (the part that reads the frames) per file. So all layers that play the same file share one loop and one offset.
  • The first of those layers in the scene decides the loop and offset for all of them.
  • A video draws at the clip's own pixel size. Its top-left corner is at the transform's position.
  • A clip with transparency (alpha) needs nothing extra in the scene. Starlight keeps the alpha when you import it (Video ingest and proxies).
  • In the graph, a video node is a dial that you can scrub.

shape

A shape layer draws a rectangle, an ellipse or a line.

PropDefaultMeaning
shaperequiredrect · ellipse · line
size100x100The box, drawn from its top-left corner. An ellipse fills the box.
fill / stroke—Fill colour and outline colour ("#hex" or $token)
strokeWidth1Outline width, in px (0 or more)
trimStart / trimEnd / trimOffset0 / 1 / 0Draw only part of the outline (Trim paths)
radius—Corner radius (rect only), 0 or more
- shape: rect            # rect | ellipse | line; anything else errors
  size: 850x18
  fill: $electric
  stroke: $ink
  strokeWidth: 2
  radius: 9
  • A rect or ellipse with no fill and no stroke draws nothing.
  • A line runs from one corner of its box to the opposite corner. It only draws an outline (a stroke).
  • A line's colour is stroke. Without it, the line uses fill. Without both, it is white.

gradient

A gradient layer fills a box with a smooth change from one colour to the next.

PropDefaultMeaning
gradientrequiredlinear · radial
stopsrequiredA list of { offset, color }: the colours, and where each one sits. Every stop needs a color. offset (0..1) is optional.
sizethe design sizeThe box it fills, from its top-left corner. By default it is the design size of the surface it draws on: the surface's own design, else the scene's.
angle0Degrees, clockwise: 0 = left → right, 90 = top → bottom. The ramp runs from corner to corner of the box, as in CSS. Linear only.
center / radius[0.5, 0.5] / 0.5Fractions of the box. A radius of 0.5 reaches the edges. Radial only.
- gradient: linear
  angle: 90
  size: 760x1700
  stops:
    - { color: $base }     # offsets omitted: spread evenly,
    - { color: $sweepMid }  #   3 stops ⇒ 0, 0.5, 1
    - { color: $base }
  • Stops without an offset spread evenly from 0 to 1.
  • An offset outside 0..1 is an error.

Animated gradients. Each of these can be a keyframe list (the values it moves through over time):

  • angle and radius
  • a stop's offset and color
  • center: { x: [..], y: [..] }
  • size: { width: [..], height: [..] }

For example: angle: [0, 90, 0] or color: ["#1E3A8A", "#86198F", "#1E3A8A"]. They follow the gradient's own clock. Without one, they follow the scene loop.

  • A list spaces its values evenly over the clock. For your own phases and eases, use the long form: [{ phase, value, ease }] (see Eases).
  • Colour keys must be hex. Tokens do not work here.
  • Colours blend in OKLab, a colour space that keeps mixes bright. So blue → magenta stays vivid.
  • A scene with animated gradient values needs schemaVersion: 4, the scene file's format version (Edit a scene by hand).
  • In the app: Pick a colour and Edit gradient stops.

path — vector shapes

A path is a vector shape made of curves (cubic Bézier curves) that you can edit. The pen makes it. It has no position of its own, so wrap it in a transform to place it. The pen does this for you.

PropDefaultMeaning
pathrequiredThe keyword value: a list of subpaths. A subpath is one outline, { vertices: […], closed }.
verticesrequiredPoints: { p: [x, y], in: [dx, dy], out: [dx, dy] }. A subpath needs at least 2 points. p is the point, in px inside the transform. in and out are its curve handles, relative to p. A corner has both at [0, 0]. A missing p, in or out is [0, 0].
closedfalsetrue joins the end back to the first point. Only a closed subpath can have a fill.
fill—Fill colour. It fills closed subpaths only.
strokewhite when open or unfilledOutline colour. The default makes sure a drawn line always shows.
strokeWidth2Outline width, in px
trimStart / trimEnd / trimOffset0 / 1 / 0Draw only part of the outline (Trim paths)
- transform:
    - path:                      # the value is a LIST of subpaths
        - vertices:
            - { p: [0, -60],  in: [0, 0], out: [0, 0] }
            - { p: [60, 40],  in: [0, 0], out: [0, 0] }
            - { p: [-60, 40], in: [0, 0], out: [0, 0] }
          closed: true
      fill: $primary          # a filled triangle
  position: { x: 960, y: 540 }

It is easier to draw with the pen than to write vertices by hand. Open the command palette with / and pick pen (Draw a path or a mask).

  • A closed pen path fills with the $primary colour token. If the scene has no primary, it uses the first colour token.
  • An open pen path draws as a 4 px outline in that colour.
  • With no stroke set, a path with a fill and a closed subpath has no outline.

Trim paths — draw part of a stroke

Trim paths draw only part of the outline (the stroke) of a shape or a path, as Trim Paths does in After Effects. Use it for a line that draws itself, a logo outline that builds, a progress ring or an underline that wipes in.

PropDefaultMeaning
trimStart0Where the stroke starts, from 0 to 1 along the outline. After Effects shows this as 0–100 %.
trimEnd1Where the stroke ends, from 0 to 1 along the outline.
trimOffset0Moves the drawn part round the outline, in degrees. 360 is one full turn. A negative number moves it back.
- shape: ellipse          # a ring that draws itself round once
  size: 300x300
  stroke: $team.gold
  strokeWidth: 12
  trimEnd: [0, 1]
  clock: { period: 2s, mode: once }
  • Only the stroke is trimmed. The fill always draws whole. A shape with no stroke has nothing to trim: give a rect or an ellipse a stroke.
  • Each value can be a keyframe list, for example trimEnd: [0, 1]. It follows the layer's own clock, or the scene loop if it has none. In the properties panel, each trim row has a ◇ to animate it (Keyframe a property), and the timeline shows each animated value as a row under the layer.
  • trimStart and trimEnd can swap: start 0.8 and end 0.2 draws the part between 0.2 and 0.8, as in After Effects. When they are equal, no stroke is drawn.
  • Where the outline starts: an ellipse at the top (12 o'clock), a rectangle at its top-right corner, both going clockwise. A line starts at its first corner. A path starts at its first point.
  • A path with several parts (subpaths) trims each part by the same amount.
  • On a closed outline, the stroke can run past the start point without a break. Spin a short arc with trimEnd: 0.25 and trimOffset: [0, 360].
  • The ends of a trimmed stroke are square.
  • The layer's box does not change when you trim, so selection and turning stay the same.
  • A trim that cuts the stroke needs scene format 16. An older Starlight asks you to update before it opens such a scene. An offset alone, or a trim that draws the whole outline, does not.

group

A group holds other nodes. Its keyword value is the list of children.

  • Its children share its clock and effects.
  • It applies no transform: it does not move, scale or turn its children.
  • Use it to give several layers one effect or one clock.
  • A bypassed group switches off its own clock and effects. Its children still draw (Turn a node off). To turn off several layers together, select them and press b.
  • Children draw in list order. The first child is at the back.
- group:                 # an L-bracket from two rects, with one set of effects
    - shape: rect
      size: 88x10
      fill: $primary
    - shape: rect
      size: 10x88
      fill: $primary

matte — cut a layer by a shape

A matte node cuts one layer by a shape. This is how masks work. It has two inputs:

  • content: what you see.
  • matte: the shape that cuts it. The shape itself is never drawn.

Each input is one node and keeps its own transform. The matte node adds no transform, so the shape stays where you place it. Its settings go inside the matte map:

SettingDefaultMeaning
contentrequiredOne node: what you see
matterequiredOne node: the shape that cuts it
modealphaalpha cuts by the shape's transparency. luma cuts by its brightness.
invertfalsetrue swaps the part that is kept and the part that is cut.
feather0Softens the edge. It is in px (0 or more), in the content's space.
opacity1The strength of the cut, 0..1. At 0, nothing is cut.
range[0, 1]Scene version 18. Two numbers, low and high (0..1). Matte values below low cut, values above high keep, and values between fade. It comes first, before the feather. On a depth matte (white = near) it picks near and far. On a soft matte it makes the edge harder.

Notes.

  • Each input takes exactly one node. To use several, put them in a group. A list is an error.
  • A group as the matte joins its shapes into one cut.
  • An adjustment layer as the content limits where its effects apply.
  • An audio layer cannot be an input. An adjustment layer cannot be the matte input.
  • bypass: true on the matte node shows the content with no cut.
  • Effects on the matte node apply to the cut result.
  • Cutting an image or a video costs no extra render pass.
  • In the app, select a layer and press ⇧M / Shift+M to draw a mask with the pen (Mask a layer).
  • The old mask: { source } field (scene version 1) becomes a matte when the scene opens.
  • A person, depth or roto matte of a clip cuts the clip from inside its transform. Its matte input is a second copy of the same clip that names the matte version (Mattes of a clip).
- matte:
    content:
      transform:
        - video: assets/plates/N-tile-a.mp4
      position: { x: 0, y: 0 }
    matte:
      transform:
        - shape: ellipse
          size: 2400x1200
          fill: "#ffffff"
      position: { x: 2000, y: 200 }
    feather: 40

adjust — an adjustment layer

An adjustment layer changes the layers below it. Write it as - adjust: {}. It draws nothing of its own.

  • Its effects, opacity (0..1, the strength, default 1) and blend apply to every node before it in the same list. Those are the layers below it.
  • Nodes after it in the same list do not change.
  • Several adjustment layers stack in list order. The upper one changes the result of the lower one.
  • To limit where it applies, make it the content of a matte.
  • Its clock drives only its opacity and the gate (a timed in and out: The gate). A clock track for anything else is an error.
  • adjust: with nothing after it, or adjust: true, also works. The app saves it as adjust: {}.
  • The cutout effect cannot go on an adjustment layer. Put it on the image.
  • In the app: Use an adjustment layer.

audio — a track on the transport

An audio layer plays a sound file, for example - audio: assets/audio/track.mp3. It draws nothing.

  • The file can be mp3, wav, m4a, aac, flac or ogg.
  • It plays locked to the transport. So a song can run longer than the scene loop.
  • It feeds the band drivers, which turn sound levels into motion (Band drivers).
  • It also feeds the musical map.
  • It cannot be an input of a matte.
  • In the graph, an audio node is a dial.
PropDefaultMeaning
volume1Loudness, 0..1
mutedfalsetrue silences it. bypass: true silences it too.
offset0The point in the track that plays at transport time 0, for example 1.5s. It must be 0 or more.
loopfalsetrue starts the track again when it ends.
exporttrueExports include this sound in their mix (Sound in exports).

use — place a copy of a comp

A use node draws a named comp at this spot. A comp is a named group of layers that you can place on surfaces (Glossary).

  • To place it, wrap it in a transform.
  • A clock, effects or blend on the use node applies to the whole copy.
  • A name that is not a comp is an error: unknown comp "…" — valid comps: ….
  • A comp that uses itself, directly or through other comps, is also an error.
  • To repeat one source across many cells, see Cloners & belts.
- use: name-chip       # draw the comp named "name-chip" here

IDs are automatic

Every node has a stable id, so scenes rarely need to write one.

  • Starlight makes the id from the node's kind and its place in the tree. It is the same on every load.
  • Write id: yourself only when a node must keep its identity after you reorder it or move it into another parent.
  • Use each id only once in a scene. Starlight does not check this for you.
  • The app writes an id itself (pin-…) the first time you move or colour a node in the graph.

On this page