The Chain Model

A chain is an ordered list of sources and effects . Sources draw images into the chain. Effects transform whatever is already there. You arrange them left to right, and the order is what determines the final look.

Sources and effects

Sources draw. They produce an image from scratch — a voronoi pattern, a plasma field, a video frame, a shader. You need at least one source to get anything on screen.
Effects transform. They take whatever the chain has drawn so far and modify it — blur it, bloom it, distort it, shift its colours. An effect at the very start of the chain has nothing to work on.

A chain with one source draws that source. A chain with two sources stacks them together. A chain with a source and an effect draws the source, then runs the effect on it. The chain runs left to right, one node at a time.

Order matters

This is the most important thing to internalise: an effect only sees what came before it in the chain — everything to its left. Where you place an effect changes what it acts on.

Take the same three nodes in two different orders:

A:  Voronoi → Plasma → Bloom
B:  Voronoi → Bloom  → Plasma

In chain A, Voronoi draws, Plasma layers on top, then Bloom runs on the combined image. Both sources end up bloomed together.

In chain B, Voronoi draws, Bloom runs on just the Voronoi, then Plasma layers on top of the bloomed Voronoi. Plasma itself is never bloomed.

Three nodes, two orderings, two completely different looks. Reordering is one of the most powerful creative tools in the app — if something’s not working, try moving it.

Stacking sources

When you drop a source into the chain, it composites onto whatever is already there — same idea as layers in Photoshop or After Effects.

Each source carries two controls for how it stacks:

Opacity — how much of it shows through. Full opacity replaces what’s underneath; half opacity mixes.
Blend mode — how its pixels combine with what’s underneath. Add, multiply, difference, and so on. There are nine — see Blend Modes.

Two sources with identical blend mode and opacity but swapped order will still look different — the later source writes into the image the earlier source already drew.

The Mix control on effects

Every effect has a Mix knob that crossfades between “off” and “full strength.” At zero the effect does nothing; at one it runs at full power; anything in between blends the unaffected and affected images together. Useful for dialling an effect in without committing to it, or for wiring up an action button that flips the effect on and off at the tap of a MIDI pad.

(Mix is an effect-only control. Sources don’t have Mix; effects don’t have blend mode or opacity.)

Groups

A group is a node that contains its own chain. Everything inside the group runs as a self-contained mini-pipeline — sources stack, effects transform, and the whole thing collapses into a single image that composites into the parent chain just like a source.

Top level:    Voronoi → [Group] → Bloom
Inside Group: Plasma → Noise → Blur

The group renders Plasma, layers Noise on top, blurs the result, and produces one image. That image then composites into the top-level chain, where Bloom sees it alongside Voronoi. Bloom never sees the blur inside the group — that effect is scoped to the group’s sub-accumulator.

Groups carry the same stacking controls as sources — opacity and blend mode — because from the parent chain’s perspective, they behave exactly like a source. A group containing only effects (“FX GROUP”) instead applies those effects to the parent’s accumulator at the point the group sits, useful for bundling a reusable effect stack.

Groups can contain groups, up to four levels deep.

Working with groups

Action	How
Group selected nodes	Select siblings, then Cmd+G (or right-click → Group Selected)
Enter a group	Double-click the group card, or right-click → Enter Group
Navigate back up	Click a segment in the breadcrumb, or press Escape
Ungroup	Right-click group → Ungroup (children move to parent; group deleted)
Delete group	Removes the group and all its children — use Ungroup to keep them

Drag-and-drop into a group drops the node inside and keeps you at the current level (Finder-style) — double-click to descend. Solo inside a group filters through the ancestor chain so you still see the group in context.

Per-source effects

Effects in the chain transform everything that came before them. But sometimes you want to blur one source without blurring anything else. The answer is per-source effects: effects attached directly to a specific source.

Every source has its own mini-chain of effects that runs on just that source’s image, before it reaches the main chain. Drop an effect onto a source’s Source Effects panel to attach it there.

Use a per-source effect when…	Use a chain effect when…
You want to treat one source	You want to treat the whole composite
The effect should follow the source around	The effect should apply where it sits in the chain
You want later chain effects to still transform the result	You want it to affect the final look entirely

Transforms on every source

Every source in Lightbridge automatically carries five transform controls:

Control	What it does
Position X	Slides the source left or right
Position Y	Slides the source up or down
Rotation	Rotates around the centre
Scale	Grows or shrinks the source
Zoom	Zooms into or out of the source’s pattern

These are universal — you get them for free on every source, and they cost nothing to leave at default.

Feedback

A chain can optionally end with a feedback pass that mixes the previous frame back into the current one. This is what makes trails, smears, echoes, and ghostly after-images possible. It runs after every other node.

Feedback is also the first thing to suspect when your output seems to “remember” something you already changed — when a chain’s history is bleeding into its present, feedback is why.

How it actually works

If you want to understand why order matters the way it does, here’s the one-sentence version: Lightbridge keeps exactly one image in flight at any moment, and each node in the chain gets a turn to either add to it or transform it.

That single image is called the accumulator . The chain walks left to right; sources draw into the accumulator, effects transform the accumulator. When the walk ends, the accumulator is what the audience sees.

A group runs that same rule recursively: when the walk hits a group, a fresh accumulator is created, the group’s children walk left-to-right into it, and the final image is handed back to the parent as if it were a source. One image per level, one walk per level.

No graphs, no branches. Just walks.

Advanced — where transforms live in the code

The transform pass is implemented in graphics/src/SourceTransform.ts as a UV remap shader pass. It runs after each source has rendered and applied its per-source effects, but before the source is composited onto the accumulator. The pass checks all five transform params and short-circuits if they’re all at defaults.

Where to go from here

How the Chain Works — hands-on guide to building your first chain.
Blend Modes — every compositing mode with its formula and typical use.
Parameter Priority — how each slider’s final value gets picked when MIDI, modulation, palette, and slider all try to drive it.