Fridays for Fusion: PROPAGATE, Finally

For those who don’t know the tool: Dominik Bargiel’s PROPAGATE is a script distributed through Reactor, the package manager for Blackmagic Design Fusion and the Fusion page in Blackmagic Design DaVinci Resolve. It addresses a modest gap in civilisation: edit one node, then apply those changes to the rest of a selection, including values, connections, expressions and animation. Fusion already lets us build formidable procedural systems. Apparently synchronising a few selected nodes required outside assistance.

One edit. Several nodes. At last.

PROPAGATE starts with a sensible idea: select several Fusion nodes, make changes to the active one, and propagate those changes to the rest. Select at least two tools, press I, edit the active tool and hit Apply Changes. PROPAGATE compares the edited state against the state it captured when the window opened and sends the detected changes to the other selected tools.

That is it.

It is useful enough to be irritating.

The important part is what PROPAGATE considers a “change”. This is not limited to ordinary numeric controls. The script iterates through the active tool’s inputs and tracks parameter values, expressions, animation, input connections and output connections. It contains specific handling for FuID and enumeration values, table parameters, Loader and Saver controls and Point data. So the useful version of the description is not “copy a slider value to several nodes”. It is closer to “make these selected tools follow the edits I just made without forcing me to rebuild those edits individually”. For Fusion users, this is bordering on decadence.

Values, expressions and things attached to them

For ordinary parameters PROPAGATE caches the initial value and later compares it with the current value. FuID and Enumeration values receive special treatment because Fusion can expose their actual value inside a table rather than as a straightforward scalar. Table parameters are compared recursively instead of relying on a simple equality check.

Expressions are tracked separately from raw values. If an input gains, loses or changes an expression, PROPAGATE treats that as an expression change rather than blindly copying the evaluated value. That is important in a procedural comp. Copying the current result of an expression would give you several nodes that merely happen to look identical at that frame. Copying the expression preserves the relationship that produced the value. Which is, admittedly, the kind of distinction Fusion users normally enjoy discovering at 18:47 on delivery day.

Connections count too

PROPAGATE also watches input connections. If an input on the active tool becomes connected, disconnected or changes its source, the script can reproduce that state across the other selected tools. It looks up the connected output and source tool rather than treating every apparently “connected” Fusion input as an external connection.

That extra check exists because animated inputs can also appear connected internally. PROPAGATE explicitly tries to distinguish real tool-to-tool connections from animation machinery such as BezierSpline and Path modifiers. Output routing is handled separately. The script caches the active tool’s output connections and can reproduce changes to those connections on the target tools, including routing several selected tools towards the same downstream target.

The developer specifically gives MultiMerge as an example of where this becomes useful. Instead of connecting a series of tools one at a time, a routing change on the active tool can be propagated across the selection.

Animation without sharing one brain

Keyframes get more careful treatment than a basic copy operation. PROPAGATE detects whether a parameter has become animated, stopped being animated or had its animation changed. The implementation compares keyframe times and values and can propagate the resulting animation to target tools.

Internal BezierSpline and Path connections are also recognised as animation structures rather than normal inter-node wiring. For Path-based point animation, PROPAGATE clones the internal Path for each target and writes the corresponding point values back to the parameter.

Points get surgical treatment

Point parameters receive another special case. The current code can determine which axes of a Point value actually changed. If you alter only X on the source, PROPAGATE can preserve the target node’s existing Y and Z values instead of replacing the entire point with the source point. The same single-axis logic is intended to apply to static points, BezierSpline keyframes and cloned Path animation.

That makes the tool much safer for groups of nodes that need one shared adjustment without becoming exact duplicates. Moving ten centres horizontally should not automatically destroy ten intentionally different vertical positions. It sounds obvious written down.

Loader and Saver controls are not ordinary controls

The source also contains specific handling for Loader and Saver tools and their Clip-related parameters. Those controls are one reason generic “copy every input value” scripting can get unpleasant quickly. Media tools contain structured data and controls that do not always behave like a normal float or checkbox. PROPAGATE’s changelog shows that Loader and Clip handling was added early in development rather than simply assuming all Fusion inputs behave identically.

Likewise, nested tables are treated conservatively. The history notes describe processing simple tables while skipping nested structures where a generic copy could become unsafe. In other words, the tool is trying to automate repetition without pursuing the traditional automation strategy of confidently breaking something more complicated.

Manual mode watches first, applies second

The normal workflow is deliberately transactional. When PROPAGATE opens, it stores the state of the active tool. You then make one or several edits. Only when Apply Changes is triggered does the script calculate what changed and propagate those differences.

Its detection order separates output connections, input connections, expressions and ordinary parameter changes. Parameter handling then avoids duplicating changes already classified as connections or expressions. Manual propagation is wrapped in a Fusion undo block named “Propagate Parameters”, so the operation can be treated as one undoable action rather than obliging the artist to reverse every copied parameter individually. There are limits to how much civilisation one script can provide, but an undo block is a respectable start.

And then there is Live Mode

PROPAGATE also contains a Live Mode. Instead of waiting for Apply Changes, Live Mode uses a timer running at 250 millisecond intervals to monitor the active tool and propagate detected edits while you work. When Live Mode is enabled, the manual Apply Changes button is disabled and PROPAGATE opens a dedicated “Propagate Live” undo block.

The current source also stores the Live Mode preference in a small configuration file so the enabled or disabled state can survive between sessions. It looks for platform-appropriate configuration locations on Windows, macOS and Linux, with fallbacks if the preferred path is unavailable.

This turns PROPAGATE from a one-shot copier into something closer to temporary multi-node editing: nominate one tool as the active source, keep the relevant targets selected and let changes spread while you work.

That is very useful. It is also exactly the sort of feature where one should confirm which nodes are selected before enthusiastically adjusting things. Fusion will do what you told it to do. Fusion has always considered that sufficient warning.

Reactor does the plumbing

PROPAGATE is packaged as an Atom for Reactor, the community package manager used with Fusion and the Fusion environment inside Resolve. The current Atom installs two files, Propagate.fu and Propagate.lua, into a Config/Propagate location through Reactor. The .fu configuration provides the integration that launches the Lua utility, while the Lua file contains the change detection, UI and propagation logic.

Reactor itself synchronises Atom packages from its Git repository and places installed content into Fusion’s Reactor PathMap structure. Current Reactor documentation covers Fusion Studio and Resolve, and the package manager exposes Lua and Python scripts through its Scripts category.

That makes PROPAGATE a relatively small addition to an existing Fusion installation rather than a separate application or processing system. There is no new media format, rendering backend or cloud service involved. It works by scripting Fusion’s own tools, inputs, expressions, connections and animation interfaces.

Why was this not always possible?

That remains the difficult part. Fusion can build large procedural composites, drive parameters with expressions, attach animation modifiers, script the application through Lua and Python, route images through sprawling graphs and turn a simple lower third into something that looks like air-traffic control for a medium-sized nation.

And yet there is enormous practical value in a little window that says, effectively: “Whatever I just did there, do it to those as well.” PROPAGATE does not invent a new compositing technique. It removes repetition from an existing one.

Changing a shared setting across ten nodes takes only a few seconds per node. Reconnecting ten nodes takes only a few seconds each. Rebuilding the same expression takes only a few seconds. Repeating a small task is rarely dramatic enough to justify fixing it, which is how it quietly survives in a workflow for years. Then somebody adds a button and the previous method suddenly looks ridiculous.