Video plugins

The OBS host

obs-ffgl

OBS Studio filter · macOS, Windows, Linux

An OBS Studio plugin that loads any FFGL 2.x bundle and renders it in OBS's own OpenGL context — no network round trip, no second render.

• Any FFGL 2.x plugin, not only ours — nothing is hard-coded
• Renders in OBS's own GL context: no round trip, no readback
• Filter and source forms, with the source list filtered to real generators
• Parameter groups and dropdowns taken from the plugin itself

The signal path

Old Cathode

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

An analogue television signal path rather than the look of one. It encodes the picture onto a colour subcarrier the way a broadcast encoder would have, damages the composite waveform as a single signal, and decodes it again with no more information than a real receiver had — then paints the result onto a phosphor screen behind curved glass.

• Dot crawl, cross-colour and coloured noise arrive as consequences of that path, not as things drawn on top of the picture
• NTSC or PAL, from broadcast or three grades of VHS, each with its own bandwidths and colour-under delay
• Four dot masks — delta shadow mask, aperture grille with its damper wires, slot mask and hard RGB stripe — living on the glass, so they foreshorten with the tube
• The controls interact the way the hardware did: losing signal costs the colour before it costs the picture

The magnet

(re)gauss

FFGL · Resolume Arena and Avenue · OpenFX · Resolve, Vegas, Nuke, Natron

A magnet next to the tube. One magnetic field over the screen, read once per electron gun — so the picture leaning, the coloured fringes on every edge and the whole regions turned the wrong colour are three symptoms of one cause rather than three effects stacked up. The Degauss button fires the coil and genuinely clears what has built up.

• Convergence error comes from the field's gradient, not its strength — the three cathodes sit in different places, so a fridge magnet on the glass fringes savagely while the Earth's field leans the whole picture and fringes nothing at all
• Purity error is the field measured in shadow-mask pitches: one whole phosphor of landing error puts the red gun on the green stripe, which is why a magnetised corner goes green rather than merely dim
• Degauss is state rather than animation — the coil's decaying field walks the mask's magnetisation down to nothing and the picture dims and swells while the high tension sags, then it magnetises again over the recovery time
• Audio drives the same field rather than a separate effect, because the default layout is an unshielded speaker and a speaker's stray field is the audio signal — so degaussing does not stop an audio-driven stain, exactly as it would not in the room
• An Interference Only mode for stacking on Old Cathode or on real CRT footage, because two shadow masks in a chain is a moiré generator

The lens

Porthole

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A variable fisheye and defish warp that re-photographs the picture through a different lens instead of bending it until it looks about right. The Projection control is which lens rather than how much: one continuous family passing exactly through rectilinear, stereographic, equidistant, equisolid and orthographic.

• Rectilinear does nothing at all, at any field of view — a flat picture re-photographed through a flat lens is the same picture, and the maths says so without being told
• Defish exactly undoes fish, because it is the same formula with source and destination swapped rather than a similar-looking inverse curve
• The frame always stays full, so strength changes the character of the warp instead of shrinking the picture into a black field
• Lateral chromatic aberration modelled separately from distortion, since a lens can have one without the other

The camera move

Vertigo

FFGL · Resolume Arena and Avenue · OpenFX · Resolve, Vegas, Nuke, Natron

The dolly zoom: the camera tracks along its own axis while the lens zooms the other way, so one surface stays exactly the size it was and everything at another distance moves. It can invent the depth it needs and work on any clip, or read a real depth map out of the picture.

• Written in disparity rather than depth, so the magnification has no pole for any setting a host can produce — there is no divide-by-zero guard in the plugin and none is needed
• The anchor surface does not move at any dolly setting, measured at nought travel while the rest of the frame travels a fifth of the frame
• A scene with no depth is the identity: a dolly zoom on a painted backdrop is nothing however hard the camera is driven, and the maths says so without being told
• Radial invents its depth field and is a closed form with no failure cases; Luma and Alpha read a real one out of the picture and are solved for, three iterations per sample
• Relief goes signed — past the middle the depth turns inside out, which is the stairwell shot rather than the subject shot
• An inverse-mapped parallax cannot leave a hole; it smears along a depth step instead, and Smooth softens the step rather than the picture

The character renderer

Asciify

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A character renderer rather than a brightness ramp. A cell is a small picture, and the glyph that stands in for it is the one whose ink is distributed most like it — how much ink there is and where it sits, measured on the same grid for the cell and for every character in the set.

• Tone is matched absolutely and shape only as a direction, because a glyph's ink is hard-edged and a cell's is soft — comparing their lengths would reject every directional glyph and collapse the effect back into a ramp
• Structure at zero is exactly the classic ASCII ramp, with no separate code path, and flat areas of the picture ignore the control on their own because a cell with no direction has nothing to be wrong about
• Every character set uses its whole range: tone maps into the measured minimum and maximum ink of whatever is selected, which is the only reason the box-drawing set responds to Structure at all
• The ramp is measured off the font rather than written down, so the traditional set comes out in this font's own order — with the hyphen outweighing the colon

The measurement

Scopes

FFGL effect · Resolume 7.3.1+ · deliberately not ported

Waveform, vectorscope, histogram and picture assist in one effect, either replacing the picture on a monitor layer or sitting over it in a corner. It measures what is arriving at that point in the layer's chain, which is a different question from what the clip file contains — and the plugin is careful to say so.

• Matrix, range and unpremultiply are explicit settings rather than heuristics, because none of the three is recoverable from the pixels once the engine has the texture — and each one guessed wrong is plausibly wrong rather than obviously wrong
• The vectorscope's target boxes are computed from the matrix the shader plots with, so choosing a matrix moves the boxes and the trace together instead of quietly making a mismatched clip look correct
• Histogram bins accumulate in 32-bit float, because in half float the tallest bins stop counting first — which are exactly the clipped whites and crushed blacks the histogram was opened to find
• Picture assist is the picture itself recoloured — false colour, zebras and focus peaking — rather than a fifth panel to read
• The one plugin without an OpenFX build, on purpose: Resolve’s own scopes are better than anything an effect can draw, and a port that exists only to be worse than the built-in tool is not worth shipping

The audio field

Spasis

FFGL sources · Resolume 7.3.1+ · no OpenFX, because there is no live audio to capture in Resolve

Four sources that draw the shape of the stereo and surround field — where the energy is pointing, how wide each part of the spectrum is, and what the balance looks like — as displays you put on a screen rather than in a meter bridge. They are sources rather than effects: nothing arrives on a layer, because what they measure is the audio, not the picture.

• The stereo layout is ±45°, not the ITU ±30°, and that is the whole design: at 45° the amplitude-weighted sum of the unit vectors to each speaker comes out as exactly (side, mid), which IS the classic goniometer — the generalised law and the instrument engineers already own are the same thing, and only at that angle
• It opens its own multichannel capture device, because FFGL hands a plugin one buffer of magnitude bins of a mono sum — no phase, no channels, no time domain — and three of the four displays cannot be drawn from that at all
• Left on the host's own FFT it draws tonal balance and leaves the other three showing their graticule and nothing else: an empty instrument rather than a black frame, because a plausible picture of nothing is the one outcome worse than no picture
• Width is 1 − |ΣX|² / (N·Σ|X|²), which reads what the |S|/(|M|+|S|) meter every mastering engineer owns reads at every landmark and keeps working past two channels
• LFE contributes a level and never a direction, and height channels are shaded rather than moved — a flat picture cannot show elevation, and putting a ceiling speaker somewhere on the horizontal plane would be inventing a position

The keyer

Resolume Luma Keyer

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron · After Effects, Premiere Pro

A luminance keyer. It measures the perceptual Rec. 709 luminance of each pixel and drives that pixel's alpha from it, so dark — or bright — areas of a clip go transparent and let lower layers show through, with no dedicated key colour to pick.

• Threshold and Softness, from a hard cut to a gradual falloff across the key edge
• Invert, to take out the bright pixels instead of the dark ones
• Straight colour internally, premultiplied and clamped to LDR on the way out, matching Resolume's own pipeline
• The quick answer to a black background, add-blend-style content, or a shadow or highlight matte

The lights

Tinsel

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

Finds the outlines in whatever is on the layer, hangs a string of virtual lamps along them, and runs the sort of pattern an LED controller runs — chases, comets, twinkles, fire, a scanner, a wipe. Point it at a logo and it becomes a neon sign, a theatre marquee or a Christmas tree.

• An effect never chooses a colour — it says where in the palette a lamp sits and how bright it is, which is how an LED controller is built and why twenty patterns and sixteen palettes are worth more than thirty-six of either
• A lamp is a fixed size in pixels, not in strip units — the difference between lamps and streaks
• The temporal filter is asymmetric on purpose: edges appear at once and are given a few frames to come back when they vanish, because what goes wrong on footage is dropout, not movement
• Randomness is an integer hash, identical on every GPU and in the offline harness

The console

NESolume

FFGL · Resolume · OpenFX · Resolve, Vegas, Nuke, Natron

A retro games console between your content and your output: a real machine's raster, palette and attribute cells, and the ways all three fail. Nine machines from the Game Boy to the PlayStation, with dither, attribute clash and a glitch section that corrupts indices rather than pixels.

• Nothing a failing machine shows is ever outside its palette — corruption happens to the indices, before colour choice, and a harness checks every rendered pixel to hold it to that
• Attribute clash falls out of enforcing the cells: the NES's 16×16 areas bleed chunky, the Spectrum's 8×8 cells argue per character
• Displacement is scroll-register damage in whole pixels and whole tiles, wrapping at the edges, so heavy settings read as a machine failing rather than an effect succeeding
• At Glitch Rate zero the corruption is a still — a crashed machine, not a screensaver

The generator

Downpour

FFGL source and effect · Resolume 7.3.1+ · OpenFX pair · Resolve, Vegas, Nuke, Natron

Digital rain: columns of characters falling at their own speeds, each with a bright leading glyph and a trail fading out behind it. Ships as two plugins — a source that draws over its own background, and an effect that draws the same rain over the clip it sits on.

• Junk characters, generated code, four public domain books, your own text or any file you point it at — a loaded document plays out in order rather than being sampled from
• Any installed font, rasterised into the glyph atlas, with a per-character fallback to the plugin's own drawn face so a typeface with no katakana still renders the katakana
• Every cell is a closed-form function of its column, its row and the clock — no simulation state, so the rain cannot slow down when the host's frame rate does
• Separate colours and opacities for the text, the leading glyph and the background, so it composites over footage without a second layer

The shapes

Orrery

FFGL source and mask · Resolume 7.3.1+ · OpenFX pair · Resolve, Vegas, Nuke, Natron

Primitive shapes moving on deterministic paths — for a quick animated mask, and for driving a pixel map. Ships as two plugins: a source that draws shapes over its own background, and a mask effect that draws them over the clip, or cuts them into it.

• Every shape's position is a closed-form function of its index and one phase number — a bounce is a triangle wave, not a collision test — so a chase cannot slow down when the host's frame rate does, which is the thing that matters when the output is driving lights rather than a screen
• Because phase is just a number, locking to the track costs no separate code path: Sync swaps the host clock for the host's own bar position, or hands the whole thing to a keyframe or a MIDI fader
• Eight primitives with outline, roundness, stretch and edge softness — and softness at zero gives a hard edge, because a feathered one means a fixture on the boundary reads a half-brightness colour that was never in the design
• Five paths, and Spread distributes the set along one in phase — which is what turns a clump into a chase that arrives in order, while Scatter takes the same set from metronome to swarm

The screensavers

Idler

FFGL source and mask · Resolume Arena and Avenue · OpenFX pair · Resolve, Vegas, Nuke, Natron

The eleven screensavers that shipped with Windows 95 and 98 — Mystify, 3D Pipes, 3D Maze, Flying Windows and the rest — as a source that draws over its own background and a mask effect that draws the saver over the clip. One dropdown for the eleven, with a factory preset per saver that sets it up the way it actually ran.

• Every saver is a pure function of time and a seed — nothing integrates a velocity and nothing remembers the previous frame, so a Mystify polygon bounces off a triangle wave rather than a collision test and none of it comes apart from the music when the host's frame rate drops
• 3D Pipes and 3D Maze genuinely grow, so they cannot be closed-form: rather than give those two an exception they are made deterministic by replaying from the seed, which keeps them scrubbable and grows the same plumbing on the show laptop and the rack machine
• The eleven share seven scene controls, each mapped to whatever that saver has that is analogous — and Colour Mode is the one worth knowing, because it puts the whole set under one tint, spread or cycle instead of eleven period palettes
• Some of it the originals could not do at all: streaks on the starfield, wireframe on the FlowerBox, and all eleven over transparency
• Not affiliated with Microsoft, and no Microsoft code, artwork or assets are included — the Flying Windows logo is a four-quad gesture toward the mark, and the teapot is generated from a profile curve rather than being Newell's dataset

The arcade

Coinop

FFGL source and effect · Resolume Arena and Avenue · no OpenFX build yet

Fourteen arcade games — Snake, Bricks, Marchers, Rally, Drift, Stacker, Chase, Girders, Swarm, Trails, Reflex, Rafters, Duel and Flapper — playing inside the composition as a source and a matching effect. Drive them from a MIDI pad or an OSC fader, or leave the autopilot to play and lose on its own — and in the effect the brick field is built out of the clip, so breaking a brick punches a hole through to the layer below.

• FFGL has no keyboard and no gamepad, it has parameters — so every control is one, and Resolume will MIDI- or OSC-map any of them: a fader for the paddle, four pads to steer, one to fire, and Rally's two players out of a single instance
• Presses are latched on the edge the host delivers them rather than polled at render time, because a press that starts and ends between two frames is invisible to a poll, and at 50fps that is a 20ms window a drummer hits constantly
• The autopilot has to lose, which makes it a feature rather than a quality bar: a perfect Snake AI never dies and leaves the layer showing the same slowly-lengthening snake all night, so Skill governs deliberate incompetence — tracking error, reaction lag, and a flat chance of ignoring its own survivability analysis
• Everything is drawn as cells rather than geometry, including Drift's vectors, because the second job is pixel mapping — and a one-pixel antialiased line sampled onto a 30mm pitch wall lands between fixtures and disappears

The sprite sheet player

Flipbook

FFGL source and effect · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A page of stills, cut into a grid and played as an animation — VFX sheets, game sprite rows, pixel art kept as pixel art, or an animated GIF that brings its own frame count. The effect can take the clip it sits on as the sheet, so Resolume's own media management does the file handling.

• The frame on screen is a closed-form function of the clock rather than a counter that gets advanced — a player that ticked once per rendered frame would run at whatever rate the host managed that night, land a quarter of a frame short per bar, and be visibly adrift by the end of the track
• Start Frame and Frame Count cut any contiguous run out of a sheet and wrap past the last cell, so a four-frame idle and an eight-frame run are two parameter sets on the same sheet rather than two files
• Up to sixty-four copies in a grid, a ring or a scatter, and Stagger offsets each copy's position in the run — which is what turns a wallpaper of sprites all doing the same thing into one animation travelling through the field
• Nearest-neighbour sampling and a half-texel inset, so a 32px sprite scales to a metre of LED wall with its edges intact and no cell ever bleeds into its neighbour

The oil wheel

Flenser

FFGL source and effect · Resolume Arena and Avenue · OpenFX pair · Resolve, Vegas, Nuke, Natron

A liquid light show: oil, water, alcohol and dye between two watch glasses on an overhead projector. Ships as two plugins — a source that is the wheel with its own lamp behind it, and an effect that puts your clip where the lamp was, so the footage is what shines through the oil.

• The colour is subtractive — every cell is a dye filter, so where two cross they multiply and go darker. Cyan over magenta is blue, not white
• Every cell's edge is a lens: it displaces what is behind it, splits it by wavelength, and throws a bright caustic just inside a dark rim
• Merge takes the wheel from separate hard-edged beads, which make a mask or a pixel-map driver, to pools joined by a proper meniscus fillet
• Everything is a closed-form function of position and time, so any frame renders on its own and scrubbing shows the wheel at that moment rather than restarting it

The synthwave engine

Outrun

FFGL effect · Resolume · live WebGL2 demo

Two engines behind one dropdown: trace the clip's outlines as neon tubes that break away from the real geometry, or generate the perspective grid, tunnels, circuits and an audio oscilloscope outright. Sixteen authored palettes, beat and bar sync, and the same GLSL running live in the browser.

The console

Cartridge

FFGL source · Resolume Arena and Avenue · macOS and Windows · no OpenFX build

A libretro frontend as a source layer: point it at an emulator core and a game and the console becomes a layer you can composite, key and run through everything else in the rig — with the joypad MIDI-mapped onto whatever controller is already on the desk. It was built as a companion to Old Cathode, because a 240p frame through a real composite encoder is the thing it exists to make possible.

• Ships as two builds of one frontend, differing only in which process the core runs in: in process the picture arrives the same frame it was produced and a crashing core takes Resolume with it; out of process it arrives a frame later and a crash kills only the helper
• The pad is twelve ordinary boolean parameters, so Resolume MIDI-maps, keyboard-maps and automates them with no help from the plugin — a hardware controller becomes a joypad, and a game can be keyframed as a visual
• Hardware-rendered cores are refused deliberately and with a log line, because giving them a half-kept promise makes them render into Resolume's own framebuffer. Software cores only
• No emulator core, BIOS image or game is included and none ever will be — several cores worth using carry non-commercial terms, and shipping one would take this repository's MIT licence with it

The pen

nib

FFGL effect · Resolume Arena and Avenue · macOS and Windows · no OpenFX build, no demo

Line drawing rather than edge glow: continuous, closed strokes in ink on paper. It works out which way the drawing runs before it filters, then runs a band-pass across the flow and a smoothing along it — so a pixel whose neighbours agree survives, and one that fired on its own does not. Eight instruments, from Pen and Ink to Cyanotype and Woodcut.

• A conventional edge effect asks how fast tone is changing at each pixel, which is a magnitude with no memory of direction — it cannot tell a stroke from a speck, and its answer at one pixel has nothing to do with its answer at the neighbour along the same line
• Turning Flow to zero skips the along-the-stroke pass and leaves plain isotropic XDoG, the effect without the idea in it. That A/B ships as a preset, because a claim you can check in one click is worth more than one you have to believe
• The flow field is measured rather than asserted: the harness renders rings whose tangent direction is known in closed form, adds noise, and reports the plugin's own error in degrees against it
• Detection runs on luminance, a single channel or saturation — a red line on a blue field has enormous chroma contrast and almost none in luma, so that last one is ordinary rather than exotic
• Still early: v0.1.3, never yet loaded into Resolume, and everything claimed for it comes from the offline harness driving the real plugin class

The frame queue

Afterglow

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A queue of the last few dozen frames laid back over the picture, each one further gone than the one in front of it — an FFGL effect for Resolume and an OpenFX plugin for Resolve. Not a blur and not a feedback loop: every frame goes in, the whole queue comes back out, and each ghost is dimmer, coarser, more crushed and further round the colour wheel than its neighbour.

• A queue of 4 to 32 real frames, with Hold spreading a dozen ghosts across two seconds, and Decay shaping how the weight falls away along the trail
• Four ways to combine the queue — a weighted average, added, screened, or the brightest of them — each with its own weight schedule, because a sum and a composite do not take the same alphas
• Ageing that is more than a fade: Crush collapses 8 bits down to 1, Pixelate coarsens to six cells across the frame, Warp pulls the picture apart with a boiling noise field, and Drift, Zoom, Spin and Hue Shift carry the ghost away
• Halation with its own size and tint, and Bleach, for the bloom around a bright trail

The drawing machine

Cogwheel

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A Spirograph for Resolume and Resolve — a toothed ring, a wheel rolling in mesh with it, and a pen in one of the wheel's holes. Nothing evaluates a curve: the ratio is two integers because gears mesh, so 96 and 32 close in a single turn with three lobes while 96 and 31 take thirty-one turns and lay down ninety-six. Ink is subtractive, so two pens crossing darken the way they do on paper.

• The ratio is two integers because gears mesh — 96 and 32 close in a single turn with three lobes, while 96 and 31 take thirty-one turns and lay down ninety-six
• Nothing in it evaluates a curve: a wheel cannot roll by anything other than a whole tooth, so every property of the figure follows from the two tooth counts
• Ink is subtractive, so a second pen crossing the first gives the product of the two transmissions — the muddy near-black it is on paper, not a lighter blend
• Ships as two plugins: the machine with its gears visible, and the drawing on its own

The feedback rig

Escapement

FFGL · Resolume 7.3.1+

A model of an optical video feedback rig for Resolume — a camera looking at a screen through glass that splits the light. The fractals are what the loop settles into rather than anything it draws: Sierpinski, Koch, the Heighway dragon and Barnsley's fern are tap configurations, and the zoom is endless because it is a rate rather than a coordinate.

• A camera looking at a screen showing what it saw a field ago, through glass that splits the light into several paths, with a proc amp in the cable
• The fractals are what the loop settles into rather than anything it draws — a set of taps is an iterated function system and the attractor is the fractal
• Sierpinski, Koch, the Heighway dragon and Barnsley's fern are tap configurations, not presets drawn on top
• The zoom is endless because it is a rate rather than a coordinate: a per-field multiplier, so the magnification is a number that exists nowhere

The chromatic aberration

Abomerration

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

Chromatic aberration as an FFGL effect for Resolume and an OpenFX plugin for Resolve — the whole visible spectrum smeared along a path and integrated, rather than three channels offset, with the beat and the spectrum of the music allowed to drive it.

• Four geometries — radial like a real uncorrected lens, linear like a prism, tangential like nothing at all, and a drifting turbulent noise field
• Spectral integration from a hard three-sample RGB split up to a 32-sample prismatic fringe, with the weights normalised so the setting changes quality and never tint
• A beat pulse locked to the host's transport, on any division from a quarter beat to two bars, with a decay from a linear ramp to a click
• Band split driving red, green and blue from bass, mid and treble separately — four routes, including bass-only and treble-only for dense mixes

The companding circuit

Compander

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

An analogue radio mic's companding circuit with a picture pushed through it — an FFGL effect for Resolume and an OpenFX plugin for Resolve. A compander's attack and release, applied to video, is a distance along the scan, so one control runs from haloing tight to every edge to the whole picture pumping.

• Compression and expansion set independently, so half the chain can be run on its own — the encode-only and decode-only characters are settings, not modes
• Time Constant from 0.1 microseconds to 40 milliseconds, which on a picture is a distance along the scan: edge haloing, horizontal smear, line-to-line streaking, whole-frame pumping
• A causal detector that trails to the right of bright objects and wraps line to line, the way a serial signal does
• Pre-emphasis in dB, with Tilt as the mismatch between the transmitter's network and the receiver's — matched, none at all, or applied twice

The tape path

Ferric

FFGL · Resolume 7.3.1+

The video signal put on tape, as an FFGL effect for Resolume — an unsteady transport tears the picture in time, the oxide adds its own hiss and dropouts, and the consumer sliding-band noise reduction that hid one under the other is in there with both ends of it under your control.

• Wow, flutter, scrape flutter and a slow drift, evaluated as one time-base error at each pixel's own tape time — so the flutter wave scrolls down the picture between frames rather than standing still
• Four transports — Cassette, Reel to Reel, Video Head and Failing — which multiply your controls rather than replacing them, and set which components dominate
• Tape Speed, from a rigid frame to the picture coming apart into ribbons, because it decides how much of the error signal fits inside one picture
• Hiss generated along the scan so it reads as horizontal video grain rather than film speckle, plus dropouts and head wear

The tape echo

Astronaught

FFGL · Resolume 7.3.1+

A model of the Roland RE-201 Space Echo as an FFGL effect for Resolume — a loop of tape, three playback heads bolted at equal intervals, a twelve-position Mode Selector and a three-spring tank, with the picture as the signal on the tape.

• A tape loop indexed by position, so changing Repeat Rate drags the echoes already recorded instead of re-timing them — measured, not asserted: after a 500 ms to 125 ms change, head 1 is still reading 450 ms-old material
• Three playback heads locked at 1 : 2 : 3 by their spacing, and the RE-201's twelve-position Mode Selector transcribed from Roland's printed table — including the three head combinations the machine does not offer
• The vertical tear and roll that a raster written down a moving tape produces, and the stretch that comes with reading it back at a different speed
• A transport that is never quite steady, so each head sees the speed error from a different moment and the three echoes chorus against each other rather than wobbling in unison

The vector CRT

Vectrix

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

An oscillator, a fourteen-block guitar and eurorack pedalboard, and a cathode ray tube in X/Y mode, as an FFGL source and effect for Resolume and an OpenFX plugin for Resolve — you are not watching a picture of an oscilloscope, you are watching where the beam went.

• Five sources: two oscillators with the X:Y ratio locked to exact rationals so a Lissajous figure stands still, parametric shapes, a 3D wireframe including a scrolling landscape with hidden-line removal, the traced edges of the clip below, and audio files
• Audio file playback drives the beam directly — left channel to X, right to Y — which is how oscilloscope music works, in WAV, AIFF, MP3, FLAC, Ogg and Opus
• Fourteen effects in a fixed pedalboard order, each able to process both axes, one axis, or the mid/side pair — and an effect applied to one deflection axis and not the other is a geometric transform of the figure rather than a filter
• Phosphors are a measured table rather than a tint: P31, P1, P2, P7, P11 and P39, with two layers and real energy transfer, so P7's long trail is a different colour from its blue strike

The chroma lattice

Macroblock

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

Chroma subsampling at any level, as an FFGL effect for Resolume and an OpenFX plugin for Resolve — from the 4:2:0 your footage is already in, up to a single colour for the whole canvas, with luma on its own independent lattice and the grid following the music.

• An arbitrary chroma lattice: absolute in pixels below 64 of them, so a format preset is that format at 720p, 1080p and 4K alike, and relative to the canvas above, so the end of the travel is one colour for the whole frame at any raster
• An independent luma lattice — the inverse of every codec, and a thing no sampling format does
• Ten presets, four of them real formats: 4:2:2, 4:2:0, 4:1:1 (DV) and 4:1:0 (Video CD)
• Rec. 709, 601, 2020 and YCoCg matrices, averaging in gamma or in linear light

The rack focus

gaffer

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A simulated lens on a depth map, with the music holding it — an FFGL effect for Resolume and an OpenFX plugin for Resolve. One plane of the picture is sharp and everything else is a disc sized by its distance from that plane, with a camera rig that rings to the kick and a focus puller working two marks on the barrel.

• A real aperture rather than a blur: out-of-focus highlights bloom into the shape of the iris, with a blade count that is measurable in the result
• A camera rig of four damped oscillators driven by the arrival of the bass, so a kick rings it and a drone does not move it — and the focus comes off as the frame moves, because they are one assembly
• A focus puller with two marks and four behaviours — Follow, Pull, Sweep and Stutter — cued from the bar line, a button, or the kick drum
• Five sources of depth, including Split H and Split V, which carry a real independent depth pass at full resolution

The tilt-shift lens

Tilter

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

A tilt-shift lens as an FFGL effect for Resolume and an OpenFX plugin for Resolve — a shallow, tiltable plane of focus with a real aperture behind it, so out-of-focus highlights bloom into the shape of the iris rather than smearing.

• Four focus shapes — a linear band at any angle, a radial iris with an adjustable aspect, a tilted plane with a real horizon and a swing, and a guess at depth from the picture's own haze
• Bokeh gather with a real aperture: circular or 5 to 9 blades, rotatable, with highlight weighting that turns bright points into aperture shapes
• A cheaper separable Gaussian for when the show needs the headroom
• Show Focus paints the focus field over the picture — warm for the near side, cold for the far side — so a focal plane is placed by looking rather than by squinting at softness

The vector rasteriser

Burin

FFGL · Resolume 7.3.1+ · OpenFX · Resolve, Vegas, Nuke, Natron

SVG rendered at the resolution the frame actually needs and rebuilt when that changes — as an FFGL source and a matching effect for Resolume, and an OpenFX plugin for Resolve. Going in close stays sharp instead of turning into a bitmap, and because the paths are still separate you can draw fills without strokes, reveal a stroke along its own length, or stagger one shape against the next.

• Rebuilt at the size it is being shown, on a half-octave ladder that only ever rounds up
• The raster covers the visible window, not the document, so a deep zoom stays bounded
• Fills, strokes or both — the file's own paint, not an edge detect
• Write-on along each stroke's own length, with per-shape stagger and five orders

The press wall

Gridiron

FFGL · Resolume 7.3.1+

Point it at a folder of logos and it builds a press wall — the step-and-repeat you stand in front of to be photographed — then animates it. Scrolling reels, twinkling cells, cells that fade and change logo, or the whole wall wrapped onto a Rubik's cube that turns a slice at a time. The arrangement is seeded, never repeats a logo next to itself, and gives every sponsor exactly equal time on screen.

• Point it at a folder — stills, animated GIF and SVG, rasterised at the size the cell actually is
• Seeded arrangement: same folder and seed, same wall, across a reload and across a machine
• No logo ever touches a copy of itself, including around the hero block
• Equal airtime — every sponsor on screen the same total time per cycle, exactly

The Flash player

Amber

FFGL · Resolume 7.3.1+

Resolume opens neither .swf nor .flv, so a decade and a half of VJ loops, web animation and motion tests sits in formats nothing on the machine will play. Amber is two halves: a converter that turns them into DXV or Hap with the frame rate and transparency intact, and an FFGL source plugin that plays Flash live on a layer with its timeline and ActionScript actually running. Powered by Ruffle. No audio — FFGL has no audio path.

• Converts .flv (Spark, VP6, VP6-alpha, H.264, Screen Video) and .swf to DXV or Hap
• Plays .swf live on a Resolume layer, with the timeline and ActionScript really running
• Transparency preserved: Hap Alpha on conversion, wmode=transparent in the plugin
• Frame rate read from the SWF header and the FLV's measured average, not guessed

The cable run

5-wire

FFGL · Resolume 7.3.1+

An FFGL effect that puts a long run of VGA or RGBHV between the picture and the screen. Coax loses the square root of frequency, and that one fact gives the soft picture, the streak behind every caption and the displaced ghost — all from the same curve rather than three separate effects. The equaliser at the far end brings the picture back and lifts the noise with it; the identical filter at the amplifier does not.

• One cable, one filter: the soft picture and the streak behind a caption are the same square-root-of-frequency response, not two effects
• Strictly one-sided — edges smear to the right and only to the right, which is the difference between a long cable and a blur
• Ghosts derived from the impedance at both ends, landing at twice the cable's transit time and getting softer every bounce
• Pre-Emphasis at the amplifier and Cable EQ at the receiver: the same filter, and only one of them lifts the noise