Resolume OFX Bridge
OpenFX plugins in Resolume, and back again
What it does
An OpenFX host packaged as an FFGL plugin, so effects written for DaVinci Resolve and the rest of the OFX world can be dropped onto a Resolume clip. It's built on the OpenFX project's own host-support library, and it shows each plugin's parameters with their proper names, units, ranges and group headings, not as a row of anonymous sliders.
The obvious design, one "OFX Host" effect with a dropdown of your installed plugins, can't be done in FFGL. A parameter's type, range and default are fixed when the plugin loads, and only labels and visibility can change after that. So the generator writes one bundle per plugin instead, each a copy of the same prebuilt binary plus a JSON manifest it reads at load time. That means you generate your effects without a compiler, and every parameter comes through exactly as its author declared it.
Alongside the generator are the tools used to prove the pixel path. ofxprobe dumps a plugin's parameters and pushes a frame through it on the CPU, and ffgltest drives a generated bundle through a real offscreen OpenGL context, which is the only way to exercise the render path without Resolume itself.
There are two front ends and one implementation behind them: OFX Bridge.app, which is two paths and a Start button, and the ofxgen command line. Both call the same generator, so what ends up in a plugin can't depend on which one you used.
It goes the other way too. `ofxgen wrap-ffgl` takes any FFGL plugin and writes a self-contained OpenFX bundle around it, so an effect written for Resolume loads into Resolve, Vegas, Nuke or Natron, with its own GLSL running in a private GL context inside the new host. A wrapped Luma Key matches the hand-written OpenFX port byte for byte, so the two implementations check each other.
v0.8.0 filled in the last gap: an After Effects plugin can cross too. wrap-ae carries one into Resolve on a bare-bones After Effects host. Well-behaved CPU effects work, and anything wanting deeper application services is refused by name instead of crashed into. Chain the two generators and the same plugin goes all the way into Resolume. One effect was pushed through all three routes and came out identical.
There's also a browser version that needs nothing installed. The wrapper shells now describe their own guest when a host loads them, so assembling a wrapped plugin is just a file copy, and a web page can do that on your machine without uploading anything. It can't diagnose a plugin it never runs, which is what the desktop build is still for, and the page tells you so.
- OFX Bridge.app — choose a folder of plugins (or one .ofx.bundle), choose where they go, press Start; a progress bar and the generator's own log, with a one-click destination for Resolume's Extra Effects folder
- GPU rendering where the plugin offers it: OFX Metal is 5.4× faster than the CPU path at 1080p and is what makes GPU-only plugins work at all, with OpenGL and OpenCL paths as well
- macOS quarantine cleared as plugins are written — Resolume skips a quarantined plugin silently rather than reporting it
- ofxgen generate — scan the conventional OFX locations, or a folder you name, and write one FFGL bundle per usable plugin
- ofxgen list and ofxgen verify — show what was found and why anything was skipped, then load a generated bundle as a host would and print what it advertises
- Parameter mapping that preserves OFX types, display ranges, group headings, colour-component tagging and choice order
- ofxprobe for CPU renders and ffgltest for a real OpenGL context, so the render path can be checked without a host
- A script that builds a corpus of real OFX plugins from the OpenFX examples — necessary because a clean machine has none, even with Resolve installed
Where it stands
Released at v0.10.0 as a working prototype. v0.10.0 makes wrapped FFGL and After Effects plugins render on DaVinci Resolve's Fusion page, where a wrapped FFGL source now moves instead of freezing (checked in Resolve Studio 21.1), and lets a host load several wrapped bundles at once, which used to make Resolve abort its plugin scan. A bundle made with an earlier version needs wrapping again to get the fixes. ofxprobe, the command-line test host, now runs Generator, Transition and General contexts as well. The host, the parameter mapping and the pixel path are checked against real OFX plugins by automated harnesses in the repo, including a headless OpenGL test that drives a generated bundle the way a host would and pixel assertions on the CPU, Metal and OpenCL paths. Generated bundles have since been run inside Resolume itself on real content, so its texture sizes, premultiplication and resize behaviour aren't the open question they were. The release ships macOS universal and Windows x64. The whole Windows toolset builds and self-tests, with CPU render numbers matching macOS digit for digit, but the OpenGL render path there has never been run (the only Windows machine here is headless), and there's no Windows GUI, only ofxgen.exe. No Linux build ships. The CUDA path is written from the specification and has never been compiled or run, so the host turns CUDA plugins down rather than half-running them. Only the OFX Filter context is hosted, and licensed commercial plugins will mostly refuse to load, because the bridge says it's its own host instead of pretending to be one they recognise.
Watch it running
Nothing loads from YouTube until you press play.Watch it there instead