What is a Fuse

Fuses are .fuse files (written in Lua) that define a Fusion node: inputs, outputs, parameters, and the per-pixel processing logic. Once installed, they show up in the Effects Library like any other node, with no visual difference.

Advantages over Macros: Fuses can implement custom algorithms that existing nodes cannot reproduce. Advantages over C++ plugin development: Lua is interpreted, so there is no compiling, and you can change it on the fly.

Custom Tool

A per-pixel formula written directly in Fusion. Limited to native math operations. Not cleanly reusable.

Macro

Wraps several native nodes into a single one. No custom logic, just grouping. Reusable.

Fuse (Lua)

Arbitrary Lua code with access to the Fusion framework. Sophisticated custom algorithms, external integrations, optimizations.

Fuse OpenCL / CUDA

A Lua Fuse + a GPU kernel. Performance similar to native Fusion nodes. For heavy per-pixel processing.

Rule of thumb: start with a Custom Tool → if you reuse it, move to a Macro → if the logic gets complex, write a Fuse → if performance is critical, a GPU Fuse.

-- MyCustomFuse.fuse (minimal example)

FuRegisterClass("MyCustomFuse", CT_Tool, {
    REGS_Name = "My Custom Fuse",
    REGS_Category = "Fuses",
    REGS_OpDescription = "Custom effect node",
    REGS_OpIconString = "MCF",
})

function Create()
    -- Define inputs / outputs / parameters
    InImage = self:AddInput("Image", "Image", { LINKID_DataType = "Image" })
    OutImage = self:AddOutput("Output", "Output", { LINKID_DataType = "Image" })
    InStrength = self:AddInput("Strength", "Strength", {
        LINKID_DataType = "Number",
        INPID_InputControl = "SliderControl",
        INP_MinScale = 0,
        INP_MaxScale = 10,
        INP_Default = 1,
    })
end

function Process(req)
    -- Per-pixel processing logic
    local img = InImage:GetValue(req)
    local out = Image({ IMG_Like = img })
    local strength = InStrength:GetValue(req).Value

    -- Modify the pixels...

    OutImage:Set(req, out)
end

Basic structure: FuRegisterClass for the metadata, Create() for the inputs / outputs, Process() for the per-frame processing.

Manual

Copy the .fuse file into the Fusion Fuses folder:
~/.fusion/Fuses/ (Linux/ Mac) or %APPDATA%/Blackmagic Design/Fusion/Fuses/ (Windows).

Through Reactor

Reactor is the unofficial Fuse package manager. One-click installation from a UI, update management, hundreds of Fuses available.

Refresh

After installing, restart Fusion (or Resolve) so it loads the new Fuses.

Reactor

The unofficial package manager. Hundreds of free packaged Fuses. The central hub of the community.

WSL (We Suck Less)

The long-standing community forum. Technical discussions, Fuse sharing, support between artists.

GitHub repositories

Lots of Fuses live on GitHub (Krokodove, KartaVR, etc.). Clone them to get the code + the Fuse.

Official documentation

The Fusion manual documents the Lua API. The reference for developing your own Fuses.

• Custom effects not covered by native nodes - advanced filters, specific algorithms, external data integrations.
• GPU performance optimization - an OpenCL / CUDA Fuse for heavy, parallelizable processing.
• Integrating external libraries - access to OpenCV, NumPy (through Lua), local AI model inference.
• Standardizing a team pipeline - a shared Fuse guarantees the same behavior on every workstation.
• Custom look development - build a unique signature look you can reuse in one click with a custom Fuse.
• Ports of Nuke / After Effects plugins - some Fuses port popular effects from other software (with adjustments).

• Start with Reactor - install Reactor first, it gives you immediate access to hundreds of Fuses without writing code.
• Read existing Fuses - since Fuses are plain text (Lua), you can open them and learn by example.
• Limited Lua performance - for really heavy processing, use an OpenCL / CUDA kernel. Pure Lua is too slow per pixel.
• Test on a copy of the comp - a badly written Fuse can crash Fusion. Always work on a copy of the comp, never on the original file.
• Versioning and sharing - store your Fuses in Git for versioning and team sharing.
• Fusion version compatibility - Fuses can break between Fusion versions. Test them after an upgrade.
• Internal documentation - comment your Fuses for others (or for yourself in 6 months).
• For studio productions, also consider native C++ plugins (faster but harder to maintain).