Video plugins

An FFGL effect that puts a magnet next to a CRT. The picture leans, every edge grows coloured fringes, and whole patches turn the wrong colour, all three from one magnetic field rather than three separate effects. A Degauss button fires the coil and clears it properly.

An FFGL effect that puts a long run of VGA or RGBHV cable between your picture and the screen. Coax loses the square root of frequency, and that one fact gives you the soft picture, the streak behind every caption and the displaced ghost, all from the same curve. An equaliser at the far end brings the picture back and lifts the noise with it. Put the same filter at the amplifier end and the picture comes back without the noise.

An FFGL effect for Resolume and an OpenFX plugin for Resolve that keeps the last few dozen frames in a queue and lays them all back over the picture, each one a bit further gone than the one in front. There's no blur and no 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 model of the Roland RE-201 Space Echo as an FFGL effect for Resolume: a loop of tape, three playback heads bolted on at equal intervals, a twelve-position Mode Selector and a three-spring tank, with your picture as the signal on the tape.

An FFGL effect that runs the picture through a coder modelled on MiniDisc's ATRAC: a lapped transform on overlapping blocks, coefficients grouped into block floating units with a scale factor and a word length each, and a fixed budget of bits per block shared out by a masking model. Fine texture goes first, hard edges ring one block either side, the allocation shimmers from frame to frame, and a knock (an audio onset, or the button) drains the shock-proof buffer until the picture freezes.

An FFGL effect built on one rule: a field is a slice of time as well as a slice of lines. Combing, bob bounce, ghosting, 3:2 judder and a mis-locked inverse telecine all follow from that rule, so they aren't five separate effects, and there's no table of cadences anywhere in the source.

An FFGL effect that runs a clip through a broadcast camera's processing chain with every knob out, in the camera's fixed order and in linear light: master gain, white balance with a slow drift, a matrix, detail from pixel and line delays with coring, level dependence and a skin window, a per-channel knee, gamma and black gamma, pedestal and white clip. All the looks of a badly set-up camera come out of that order rather than being drawn on: halos the width of the delay, grain sharpened by too little coring, faces gone soft while the jacket stays sharp, highlights going milky through the knee, and a warm white that clips in one channel first.

An FFGL effect that runs your clip through a capacitor-coupled video amplifier whose clamp has failed. One RC high-pass runs in real time through every line and blanking interval of a full 625/50 or 525/59.94 field, so black wanders about with the picture content, a bright moment darkens the next one, and lines and fields tilt. Supply sag and a triode stage sit on top.

An FFGL effect that records your clip the way a VHS deck does. The chroma is heterodyned down underneath the FM luma, so colour gets about 40 lines of resolution to luma's 234 and turns up late, to the right of every edge, with noise that comes out as blotches rather than grain. A playback phase error swings NTSC's hue, but PAL's alternating V axis and the 1H average turn the same error into nothing worse than faded saturation. The heads switch 6.5 lines before vertical sync and tear the bottom of the picture, a tracking bar sits in the vertical interval and walks up the frame as the error drifts, the dropout compensator patches holes with the line before, and a copy of a copy runs the whole chain again.

An analogue radio mic's companding circuit with a picture pushed through it, as an FFGL effect for Resolume and an OpenFX plugin for Resolve. Apply a compander's attack and release to video and they become a distance along the scan, so one control runs from a halo hugging every edge all the way to the whole picture pumping.

An FFGL effect that treats each frame the way an audio editor treats a raw file: one long stream of samples in the file's own layout, run through actual delay-line effects. An echo comes back lines down and samples across, and marches down on a slant with feedback. A flanger swept in stream time combs across the scanlines. A phaser smears smooth content to the right with ringing, at unity gain. A pitch shifter stretches the scan inside grains. In an interleaved file a delay lands one channel over and every effect rotates the hue, and past full scale an 8-bit file wraps round. None of it is drawn.

An FFGL effect that sends your clip over an analogue FM satellite link (PAL, pre-emphasis, an FM carrier with energy dispersal, a noisy channel, a discriminator, de-emphasis, a clamp and a PAL decoder), run on the GPU, sample by sample. Below the FM threshold the discriminator throws clicks at Rice's rate, and they smear into sparklies, black on white and white on black, the ones a dish slightly off-pointing or a rain fade used to fill the picture with.

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 too, with both ends of it under your control.

An FFGL effect that finds the outlines in a clip and scans them the way a laser projector does, with two galvanometer mirrors chasing a point stream at a fixed rate. The bright dots at the corners, the corners rounding off at speed, the ringing and the crawl on a frame too busy to finish are all where the beam went, not things drawn on afterwards.

An FFGL mixer that keys this layer's colour 0 over the layer below the way an Amiga genlock did, on the computer's own free-running pixel clock instead of the video's. The key lands a pixel away from its fill, so every edge carries a fringe, the fringe crawls as the clocks drift, and a failing sync rolls the overlay. None of it is drawn. It's just what a key timed off the wrong clock does.

An FFGL source that draws test patterns at whatever raster Resolume hands it: SMPTE RP 219 bars, plain 75% and 100% bars, grids, an alignment chart, LED cabinet maps, flat fields, greyscale and a pixel check. Every line is a whole number of pixels and nothing is anti-aliased, so a soft edge on the wall means a scaler somewhere in the chain and never the pattern. It's Test Card's live sibling, with the three things a PNG can't do: a burn-in, a moving marker and a frame counter you can film beside the monitor to read the latency to the frame.

An FFGL effect that plays your clip as a Hi8 tape on a Video8 deck. The luma is an actual FM carrier: written by Hi8 at 5.7 to 7.7 MHz with a 0.47 µs pre-emphasis, read by a Video8 deck's channel, limiter and pulse-count demodulator built for 4.2 to 5.4 MHz and a 1.3 µs de-emphasis. None of it is painted on. The contrast comes out 5/3 too high, a glow trails every highlight, the back-porch clamp lifts the black, bright edges throw black streaks where their overshoot leaves the deck's band, and under tape noise the highlights break into sparkle first. The colour-under chroma is the same in both formats, so the colour survives, and a Video8 tape, or a Hi8 deck, plays clean.

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

An FFGL source that draws four audio meters (a VU, a BBC-style PPM, an LED bargraph and a magic eye), each moving the way its standard says it has to. The VU's damping and natural frequency are solved in code from the two figures in ANSI C16.5 rather than tuned by eye, so the needle overshoots a kick by 1.25 % and settles back because that's what the standard asks for.

An FFGL effect that models the route a picture took to get to a television, rather than just the look of one. Universal macOS bundle and Windows DLL.

An FFGL effect that puts your clip on an LED wall built the way real ones are: cabinets on a daisy-chained cable, each with its own receiving card, calibration table and scan-driven modules. Every fault is one stage of that chain lying, so the decalibrated patchwork, tiles repeated and flowing along the cable, everything downstream of a break going black or freezing, a cut rippling down the chain, zebra stripes from a stuck address line, a colour missing from one driver chip onwards, and supplies sagging and tripping all come out of the chain rather than being drawn on top.

An FFGL effect that puts your clip on an LED wall and photographs the wall with a rolling-shutter Bayer camera. Every pixel is a box laid over the LED grid and every row a window over the PWM pulse train, both integrated analytically, so the moiré, the scan bands, the low-grey breakup and the black between the pixels are what two samplings do rather than effects drawn on top.

An FFGL effect that puts a camera tube in front of your clip: a photoconductive target that stores charge, and an electron beam that reads it by discharging it and can only take so much per pass. Lag, comet tails, blocked highlights and burn-in are all what that one store of charge does, rather than effects drawn on top.

An FFGL source that's a radar watching a synthetic sea, and an effect that makes your clip the sea. A plan-position indicator is a CRT whose trace runs out from the centre along the antenna's bearing as the antenna turns, painting every echo onto a long-persistence phosphor. Nothing here is a drawing of a radar. A reflectivity field goes through a radar model, so targets paint arcs as wide as the beam and streaks as long as the pulse, the sweep leaves a fading trail, near returns are huge until STC flattens them, clutter crowds the centre, coasts facing the radar are bright edges with shadow behind them, and moving contacts leave a plot of their track.

An FFGL effect that gives every row of the frame its own moment in time, the way a CMOS sensor does. Skew, jello, flash banding and the striping from a mains-driven lamp then all come from one sample window applied to four different things.

An FFGL mixer that cuts between this layer and the one below the way a relay-switched router used to. The layer's opacity fader is the coil, with pull-in and drop-out hysteresis. The contacts bounce, so the switching frame shows bands of A, black and B at the scanlines where each hit landed. The monitor's PLL has to re-lock, so the new picture rolls and settles. And the open contact is a capacitor, so the unselected picture ghosts through, high-passed.

An FFGL effect that's a small video codec (block-matching motion search, closed-loop prediction from the decoder's own last frame, a quantised DCT residual and a GOP) with controls that break one stage at a time. Datamosh is what a decoder does with the wrong information: drop the I-frame at a cut and it paints the old picture with the new scene's motion.

A luminance keyer for Resolume Arena and Avenue as FFGL, for Resolve, Vegas, Nuke and Natron as OpenFX, and for After Effects and Premiere Pro. It comes as macOS universal and Windows x64, plus a Linux OpenFX build.

Waveform, vectorscope, histogram and picture assist in one FFGL effect. Drop it on a layer and it measures what's arriving there, either in place of the picture or over it in a corner.

An FFGL effect that runs every scan line of your clip through a one-bit delta modulator, the CVSD codec of military and Bluetooth voice: each sample sends one bit, saying above or below the decoder's guess. Hard edges arrive as ramps smeared along the scan (slope overload), flat areas get a fine two-sample dither (granular noise), an adaptive step trades one for the other, and a flipped bit knocks the rest of the line off as a streak that fades away on the leak.

An FFGL effect that sends your clip as slow-scan television (Martin M1, Scottie S1 or Robot 36 tones) through an HF channel with noise, fading, multipath and interference, and paints whatever the receiver manages to decode, a line at a time. The slant from a receiver clock a few ppm out, the colour fringes on it, the noise streaks below the FM threshold and the smear all come from the chain running at 11,025 samples a second. None of it is drawn on top.

An FFGL effect that puts your clip through the kind of box that turned 625-line, 50-field pictures into 525-line, 59.94-field ones, interpolating fields in time and in space with no idea of motion at all. The judder cycle, the double images and the soft vertical look all come out of that.

An FFGL effect that sends your clip as a Level 1 teletext page: 40 by 24 cells of 2 by 3 mosaic sixels in eight colours, where every colour change is a control code that costs you a cell. An optimal encoder plans each row, the page arrives a few rows a field and tears between rows, and bit errors land the teletext way: one bit blanks a cell, two bits corrupt a mosaic, and a row never moves.

An FFGL effect that runs the picture through a valve amplifier the way a guitar goes through an overdriven amp. Every stage is a specific valve (Norman Koren's model of a 12AX7, 12AT7, 12AU7 or 6DJ8 preamp triode, or an EL34, 6L6GC, KT88 or 300B power valve), solved on the load line of the circuit it sits in and chained like an amp: up to four preamp stages, then one power valve or a push-pull pair. None of it is a drawn curve, so the overdrive comes out of the maths: a soft fade into cutoff against a hard knee where the grid conducts, the 12AU7 that stays clean where a 12AX7 crunches, and a push-pull pair's crossover step when it's biased cold. Feed it as RGB, as Y/C with the chroma on a subcarrier so the hue survives, or as Composite.

An FFGL effect that splits the frame into eight octave bands of spatial frequency and sets each band's gain from the matching band of the audio. With every gain at 1× the input comes back untouched, to the bit, and everything else it does is built on that.

An FFGL effect that shows your clip the way a single-chip DLP does, a red field, then green, then blue, through a spinning colour wheel, and models the retina that adds them up. A still eye sees the input exactly. A moving eye lands each colour somewhere else, and that's where the rainbow fringe comes from. None of it is drawn.

An FFGL mixer that wipes this layer in over the layer below the way an analogue vision mixer did: every pattern is a waveform built from ramps and parabolas and compared against the fader. Softness is the comparator's gain, so a circle's edge is softer near its middle where the parabola is flatter. The border is a second comparator, and modulation is a sine on the waveform.

Chromatic aberration as an FFGL effect for Resolume and an OpenFX plugin for Resolve. It smears the whole visible spectrum along a path and adds it up, rather than offsetting three channels, and the beat and the spectrum of the music can drive it.

An ASCII art FFGL effect that picks each character by how much ink the cell wants and where that ink sits, so edges get characters that lean the right way instead of being flattened into a brightness ramp.

An FFGL effect that reads the picture's brightness as ground height and draws it like a survey map: contour lines at a fixed interval, heavier index contours, hill-shading from the north-west, hypsometric tints, and a sea the music can raise. Contours crowd together on steep ground because their spacing is the slope, and every line stays one pen width whether it's on a cliff or a plain.

An FFGL effect that prints your clip on a sheet of paper and crumples it under a lamp. Paper bends but doesn't stretch, so the print gets pulled in where the sheet tilts and kinks at every crease, which is the giveaway of real crumpled paper that a texture overlay can't fake.

An FFGL effect that sends your clip as a Group 3 fax (ITU-T T.4) down a noisy phone line. Each scan line gets thresholded or halftoned to black and white, coded by a proper Modified Huffman or Modified READ coder, sent down a line that flips bits, and decoded at the other end, so the glitches are the ones a real fax makes. A bit error streaks along its line to the right edge and stops, in MR it smears down as a wedge to the next one-dimensional line, a receiver that spots a bad line repeats the one above, and in Page mode the page creeps in line by line at the baud rate, exactly as slowly as you remember.

An FFGL effect that prints your clip as a grid of frames on a microfiche card and browses it through a reader the way a person does: a hand that obeys Fitts's law on a carriage with a bit of give in it, a zoom that doesn't hold focus, a card bowed between its glass plates, and a focus knob turned by someone with a reaction time. The whip pans, the overshoot and correction, the crash zooms that land soft and the hunt for focus all come from a hand magnified twenty-four times. None of it's keyframed.

A page of stills, cut into a grid and played as an animation, as an FFGL source and a matching effect for Resolume and an OpenFX plugin for Resolve. Up to sixty-four copies with a stagger, so one animation travels through the field instead of sixty-four of them doing the same thing at once.

A simulated lens on a depth map, with the music holding the camera: 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.

An FFGL effect that runs your clip through a film projector's gate, shutter and print, modelling the machine and letting the look follow. The clip is held at the projector's rate and only changes when the claw pulls down, in the dark. The light the shutter blades let through is integrated over each frame your display shows, so the flicker beats at the difference between the two rates. Each frame lands in the gate with its own correlated weave, and every mark belongs to either the print or the gate: scratches that stay put while the picture moves under them, dust that rides the print, a hair caught at the aperture, splices, reel-change cue dots, and dyes fading towards magenta.

Two FFGL plugins: an effect that prints your clip onto 35 mm, 16 mm or Super 8 film, and a source that runs the countdown leader on it. The holes, frame lines, anamorphic squeeze and soundtracks are where the published standards put them, and every frame keeps the picture it was exposed with, so a moving strip carries the clip's recent past across the screen. The optical track wiggles with the music, and the countdown and the sync flash land on the beat or the bar if you ask them to.

An FFGL effect that puts your clip through a hand-cranked camera and a hand-cranked projector. Neither hand is a motor: the cameraman's decides when each frame was exposed, so motion rushes and drags and the picture breathes lighter and darker with it, and the projectionist's decides how long each frame stays on the screen, so the flicker wanders. The print is orthochromatic or panchromatic silver, sepia toned or tinted, with grain, weave, scratches, dust and the odd hair. And there's a Run Out button that runs the reel out to blank cells.

An FFGL effect that develops your clip as an integral instant print while you watch. A Take exposes the frame, metered the way a camera would, and the print comes up out of a dark green-grey opacifier, pale and blue-cyan at first, warming to full colour as the slower magenta and yellow dyes arrive, each layer first-order at its own rate. Temperature scales every rate by the Arrhenius law, and because the timing layer that stops development speeds up less than the dyes do, cold film stops short, pale and green, as the manufacturer describes, while hot film finishes warm. A short or uneven spread leaves undeveloped corners, expired paste doesn't reach as far, and a dirty roller repeats its mark at its circumference. Shaking it doesn't help.

An FFGL effect that turns your clip into a ruled copper plate. An engraver can't pick a grey, so nothing here draws one. The line carries the tone, swelling where the picture darkens and tapering where it lightens, until the plate goes solid at black and leaves bare paper at white. The ruling follows the picture's own structure, and a second and third hatch set come in with the shadows.

An FFGL effect that weaves your clip on a jacquard loom, sticking to the loom's own rules instead of laying a cloth texture over the picture. One warp colour runs down, each pick across carries one weft colour from the shuttles loaded, no thread can float past more crossings than Max Float, and tone comes from the weave structure, twill in the midtones and satin towards the ends. Every pick's shuttle and lift pattern is chosen by an exactly optimal programme under both float limits, and the look comes out of that: colour in horizontal bands, twill diagonals, ties sprinkled through the solids, and a picture from across the room that turns into thread up close.

An FFGL mixer that shows this layer or the layer below the way a printed lenticular card does: two pictures cut into strips and interleaved under a sheet of cylindrical lenses, with the layer's opacity fader tilting the card. Each lens focuses the eye onto one point of the print, so the card flips square on and flips back at the edge of the viewing zone. A real lens's focus spot shows both pictures near the flip, a print pitch that misses the lens pitch flips in moiré bands that sweep as the card tilts, a close viewer sees the flip travel across the card, and each lens shows one stepped sample of its picture, with the ridges catching the light.

An FFGL effect that turns a clip into ink: continuous, closed strokes on paper instead of a glowing outline. Most edge effects ask how fast the tone's changing at each pixel, which gives you a magnitude with no idea of direction. nib works out which way the drawing runs first, then steers a difference of Gaussians across the flow and a line integral convolution along it, so a pixel whose neighbours agree with it survives and one that fired on its own doesn't.

An FFGL effect that photographs a clip the way a photo-finish camera photographs a race: one column of sensor with the film moving past it, so the picture's horizontal axis is time rather than space. The streaks, the stretching and the backwards runner all come from that one swap rather than being drawn on top.

An FFGL effect that traces the outlines in the current frame and draws them with a slow pen on paper the ink stays on. A trapezoidal motion planner with a speed limit, an acceleration limit and a stop at sharp corners moves the carriage by the time that actually passed, and the renderer lays down ink per unit of time, so the line is heavy where the pen is slow, every pen-down is a blot, a coarse step pitch draws staircases, and a carousel of pens costs a trip for every colour change. A few strokes in, the clip has moved on, so the sheet ends up a collage of moments.

A variable fisheye and defish warp as an FFGL effect. It re-photographs the picture through a different lens instead of drawing a bulge on top, so the Projection control picks the lens, and defish exactly undoes fish.

An FFGL effect that exposes your clip onto a three-layer colour negative, develops each layer along a characteristic curve into dye with an orange mask and grain, then scans and inverts it the way a lab scanner does. Grain that peaks in the mid-tones, the blue shadows of expired stock, a warm light leak that saturates and the warm cast of cross-processing all come from the process itself. There's no lookup table.

An FFGL effect that prints your clip on a thermal receipt printer: a line of tiny heaters, 8 to the millimetre, and no ink, just paper that darkens where it gets hot enough. It prints one dot row at a time, and the look comes from the heat rather than being drawn. Tone is a Bayer, Floyd-Steinberg or Atkinson dither. A heater that fired is still warm on the next row, so lines thicken, marks run on below themselves and dark areas block up unless the firmware's history control takes the heat off. The supply can only fire so many dots at once, so dense rows print paler and band at the strobe blocks. A slipping roller repeats or overprints rows, and in Printing mode the receipt scrolls out of the slot and tears off.

An FFGL effect that hammers your clip into a metal sheet and lights it with a lamp on a swinging cord. Brightness becomes height, a punch of a set radius decides the finest detail that can be formed, and a point lamp with inverse-square falloff, a microfacet highlight in the reflectance of copper, brass, silver, gold or steel, and self-shadowing light the relief. The lamp is a damped pendulum, and an onset in the audio, or the Kick button, gives it a push.

An FFGL effect that prints the frame instead of texturing it: four plates at their own screen angles, laid down by a press that never quite registers them. Rosettes, moiré, dot gain and overprint are all what four lattices and some ink do, rather than effects drawn on top.

Two FFGL plugins, a source and an effect that draws over your clip, that doodle the music into the air: rings of sound on the kick, impact stars on the snare, zigzag bolts on the big hits, curls off the hi-hats, and one long wobbly line that's the spectrum. Every doodle is drawn again for every drawing, 24, 12 or 8 times a second, by a hand that can't hold still, so every line boils the way hand-drawn animation does. It listens to Resolume's audio input, and follows the beat when there's nothing to hear.

An FFGL effect that cuts your clip into a stencil and sprays paint through it. A stencil can't hold a floating piece: cut out an O and its middle drops out. So every island in every layer gets the shortest bridge there is to another piece of sheet, found by a jump flood on the GPU and picked on the CPU, round and round until nothing floats. Then the holes are sprayed through a nozzle's footprint. The look comes out of that: the gap in the O where its ring is thinnest, islands inside islands hung off the frame, layers sprayed dark over light, a halo in proportion to Distance, ghostly bridges under a lifted sheet, and drips.

A tilt-shift lens as an FFGL effect for Resolume and an OpenFX plugin for Resolve: a shallow plane of focus you can tilt, with a proper aperture behind it, so out-of-focus highlights bloom into the shape of the iris instead of smearing.

An FFGL effect that finds the outlines in a clip and lights them like a string of LEDs, running the sort of patterns an LED controller runs (chases, comets, twinkles, fire) across twenty patterns and sixteen palettes.

An FFGL effect that runs your clip through a xerographic engine up to eight times a frame, each copy made from the last: optics, an auto-exposure that throws the background away, a steep photoconductor, development that follows the electric field above the latent image rather than the image itself, a toner supply that runs short, and a drum whose defects repeat down the page. Greys collapse to paper or toner, wide solids go hollow while thin lines print full, the page runs out part-way down, and the skew drifts a bit further with every generation. Much like the office copier, minus the paper jams.

An FFGL effect that machines the bright part of your clip as a CNC pocket. One jump-flooded distance field gives the offset passes, and a round tool runs them at a feed rate into a cut that stays cut. The fillets in the inside corners, the slot too narrow to get into and the scallops between wide passes all come from the geometry. Nobody draws them.

An FFGL effect that does the shot where the camera tracks backwards while the lens zooms in, so one surface stays the size it was and everything at any other distance moves. It can make up the depth it needs, so it works on any clip, or it can read a real depth map out of the picture.

An FFGL effect that exposes your clip onto a collodion wet plate. The plate only sees blue and ultraviolet, weighted by a published sensitivity curve integrated against a spectrum built from each pixel's RGB, and it's slow, gathering light over a sliding window of seconds, so anything that moved is a ghost as dense as the fraction of the exposure it stayed for. Reds go black and skies go white, motion stacks up into ghosts, a take exposes and then holds the developed plate, and the hand-poured coating drains towards one corner, with a bare pour edge and dust comets. Tintype, ambrotype or glass negative.

An FFGL effect that prints your clip onto the cards of a spinning disc and shows you the disc only in the light of a strobe that fires on the music. Lock the disc to the tempo and the figures stand still and play; nudge it off and they crawl forwards or backwards; spin it by hand on the kicks and they jump. Nothing's animated by the plugin: the print head, the disc, the strobe and the camera do it all, and a Drum view shows the cards through slits the way the Victorians did.

An FFGL source that simulates six 555 timers at the component level (a capacitor, two comparators and a flip-flop each) and patches them into the X, Y and brightness of a television's deflection yoke. Nothing gets drawn as a shape. The picture is wherever the beam went, brightest where the beam was slowest.

An FFGL effect that turns the frame into a lava lamp, and the lamp is a working heat engine. A bulb warms wax that's denser than the water when it's cold and lighter when it's hot, so it rises, cools at the cap and sinks again. Bass drives the bulb and salt sets the water. The pillars that neck and pinch off, and the stalls, come out of the physics rather than being animated.

An FFGL source that's the night sky, and an effect that adds the aurora to your clip as light. The arc is a vortex sheet of electric charge that rolls itself up into curls, folds and surges, the electrons it speeds up light each spectral line at the height a real atmosphere puts it, and a camera on the ground looks up through the lot. There isn't a noise function anywhere in it.

SVG drawn at the resolution the frame needs and redrawn when that changes, as an FFGL source and a matching effect for Resolume, and an OpenFX plugin for Resolve. Zoom in close and it stays sharp instead of going soft like a blown-up 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.

A Spirograph for Resolume and Resolve: a toothed ring, a wheel rolling round in mesh with it, and a pen in one of the wheel's holes. Nothing evaluates a curve. The ratio is two whole numbers 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 go darker, the way they do on paper.

An FFGL effect that turns your clip into a ball of hot plasma held in a magnetic bottle. The plasma follows 2.5-D compressible ideal magnetohydrodynamics, solved on the GPU every frame, and the bottle is the closed-form field of real coils standing outside the picture. The ball swells against the field, rings, writhes, leaks through the cusps and breaks into fingers, and if you quench the coils it goes up as a fireball.

An FFGL source that plays Conway's Game of Life, and an effect whose clip seeds the field. It's a grid of cells, each alive or dead, all updated at once by one rule over the eight neighbours, and nothing in it is a drawing of Life. The gliders, spaceships, blinkers and pulsars, Gosper's gun firing a glider every 30 generations, methuselahs boiling away for a thousand generations and a soup burning down to ash all come from the rule. Twelve relatives of Conway's rule are one dropdown away, cells are coloured by their age, and the field reseeds itself once it's settled down.

Columns of falling characters, as an FFGL source and a matching effect. It can rain its own made-up code, four public domain books, or any text file you point it at, in any font you've got installed.

A model of an optical video feedback rig for Resolume: a camera looking at a screen through glass that splits the light. Nothing in it draws a fractal. Sierpinski, Koch, the Heighway dragon and Barnsley's fern are what the loop settles into for different tap configurations, and the zoom never runs out because it's a rate and no coordinate is ever stored.

An FFGL effect that turns your clip into a wall of incandescent bulbs, each one a tungsten wire with its own heat balance rather than an LED with a slow fade. Each bulb's dimmer is set by its cell of the clip, and the filament does the rest: electrical power in through tungsten's resistance, which is fifteen times lower cold than hot, radiation out as T to the fourth, and conduction out, all against the wire's heat capacity, solved per bulb on the GPU through the mains waveform and a sine, square-law or triac dimmer. Dimmed bulbs go red as well as dark, flashes come up fast and die away slowly, cold bulbs surge, small lamps ripple at twice the mains, and big lamps lag.

Oil, water, alcohol and dye squashed between two watch glasses on an overhead projector: the 1967 liquid light show, as an FFGL source and a matching effect that puts your clip where the lamp was. The cells are dye filters, so where they cross they multiply rather than add.

An FFGL source and effect full of high-voltage discharges: a Jacob's ladder, a Tesla coil, a Van de Graaff generator, a plasma globe and a Lichtenberg figure. Every spark is grown by the dielectric breakdown model on an actual Laplace solve, and each machine's own circuit decides when the air gives way and how much light comes out. The branching, the forks heading for the nearest ground and the strike that takes the short way round all end up where the field puts them.

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

An FFGL source that's a thin layer of reagents in a dish on a lightbox, and an effect where your clip is the lightbox. There are eight reactions, each from its published mechanism: the Belousov–Zhabotinsky reaction's target waves (and spirals, with Excitability turned up), the Briggs–Rauscher reaction's colourless–amber–blue-black cycle, the iodine clock's snap (dosed so it lands on the bar), CDIMA Turing spots and stripes, the traffic light, the blue bottle, the vanishing valentine and the chemical chameleon. There's no palette anywhere: every pixel is light that's been through each species' absorption spectrum.

An FFGL source that runs Langton's ant, and an effect in which the ants walk your clip. An ant on a grid of black and white cells turns right on white and left on black, flips the cell and steps on. That's the whole rule, and nothing in the plugin draws a picture of an ant's walk. For about ten thousand steps it makes a mess nobody has found any order in, then it starts building a highway and never stops. Turk and Propp's many-coloured ants are a dropdown away, up to eight ants take turns, and the walk runs backwards exactly, so the chaos can un-happen into the empty grid it came from.

An FFGL effect that puts a pond over your clip: drop a pebble, skim a stone or let it rain, and the water follows the water-wave equations to the letter. The still disc inside the ring, the long waves racing ahead, the caustic net on the bed and the sun's glints all come out of the physics rather than being drawn.

Simple shapes moving on deterministic paths, as an FFGL source and a matching mask effect. Eight shapes, five paths, and a phase you can lock to the host's bar, for quick animated masks and for chroma chases driving a pixel map.

Neon synthwave strokes as one FFGL effect with two engines. One traces the clip's outlines as glowing tubes that can break away from the geometry underneath. The other makes synthwave paths from scratch: the perspective grid with the striped sun, tunnels, circuits, skylines, and the routed audio as an oscilloscope.

An FFGL source that throws polyhedral dice onto the table, and an effect that throws them over a clip. The d4, d6, d8, d10, d12, d20 and the d100's pair tumble with proper rigid-body physics, bounce off the frame's edges and each other, and land on a random result or on the total you set, at exactly the Roll Time you set. Every die is face-transitive, so the throw is simulated straight and the die is then drawn turned by whichever symmetry puts the wanted number on top: the motion is the physics', and only the paint has turned. Numbers in any installed font, and faces in marble, pearl, metal, gem, stone, wood, galaxy, a picture or a wireframe.

An FFGL source that puts the Test Card's pumpkin patch into Resolume: a jack-o'-lantern on every LED tile, each carved with one of six faces, its candle flickering and its face blinking, winking or chomping in its own time. It isn't a pumpkin like the test card's, it's the test card's pumpkin: the drawing, the timing and which face lands on which tile are its code, ported line for line and checked against the test card itself, so the same seed and tiles deal the same patch. Set its clock to the wall and it flickers in step with a test card on another machine.

An FFGL effect where a loudspeaker fires a pulse of sound into the air on every beat, or on every hit in the music, and you watch your clip through that air with a schlieren camera: a knife edge, a colour wheel, a shadowgraph screen or a distant backdrop. The rings, the light and shade either side of them, loud hits cracking into shock waves and the echoes off the edges of the frame are the acoustics and the optics, worked out in real units. Nothing's drawn.

An FFGL source and a matching mask effect for Resolume. Shapes slide in from whichever edge you choose, stop a set distance in, bank up behind one another (overlapping, newest on top) and get drawn away off the far side. You can set the spacing in multiples of the shape's own thickness, or in absolute pixels for a pixel map.

An FFGL source and an effect that build space pictures the way NASA's are made: gas lit by the stars inside it, seen through Hubble's and Webb's real filters, each filter's grey image given the colour its release gave it. Fifteen famous targets from the Pillars of Creation to Webb's First Deep Field, seven generative skies, and meteors, a supernova and its light echo on a button. No photograph is shipped or sampled; the light is worked out.

An FFGL source and an effect for jumping to hyperspace: a camera flying through space with its shutter open, so the stars stretch into streaks because the camera moves while the shutter's open, which is all the films' hyperspace ever was. Four looks: Hyperspace, a Warp jump with its rubber band and flash, a Wormhole of whirling cloud, and a Black Hole done properly, with its shadow, a lensed sky (or your clip bent into an Einstein ring), a disc whose far side is lensed over the top, and a photon ring that nothing draws.

Four FFGL sources that draw the stereo and surround field as sonar-style displays rather than meters, showing where the energy's pointing, how wide each part of the spectrum is and what the tonal balance looks like. They open their own multichannel capture device, because FFGL gives a plugin nothing but a mono magnitude spectrum and three of the four can't be drawn from that.

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. What you're watching is where the beam actually went.

Resolume opens neither .swf nor .flv, so a decade and a half of VJ loops, web animation and motion tests is sitting in formats nothing on the machine will play. Amber comes in 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 running. It's powered by Ruffle. There's no audio, because FFGL has no audio path.

A libretro frontend that runs inside Resolume as an FFGL generator. Point it at a core and a game and the console becomes a layer, with the joypad MIDI-mapped onto whatever controller's already on the desk. It comes as two builds: in-process, and an out-of-process helper that keeps the show up when a core crashes. No cores, BIOS images or games are included.

Snake, Bricks, Marchers, Rally, Drift, Stacker, Chase, Girders, Swarm, Trails, Reflex, Rafters, Duel and Flapper, as an FFGL source and a matching effect for Resolume. Play them from a MIDI pad or an OSC fader, or leave the autopilot to play and lose on its own. In the effect the brick field is made out of the clip, so breaking a brick punches a hole through to the layer below.

An FFGL source that plays an Amiga cracktro (copper bars, a sine scroller, a starfield, a spinning cube and bobs), written against an emulation of the chips that drew them: chip RAM, the copper, 32 twelve-bit colour registers, five bitplanes, eight sprites and the blitter. Crossing bars can't blend because a register only holds one value, a mid-line colour change lands on the copper's four-pixel grid, and every channel is a multiple of 17 because a gun has four bits.

An FFGL effect that shows your clip on an electromagnetic flip-dot sign: a grid of discs, black on one side and fluorescent on the other, each swung from one face to the other by a coil and staying put with no power. The driver scans the sign a column or a row at a time and only pulses the discs that need to change, so a new picture wipes across at the scan rate, with every disc in a line starting its swing the moment the driver gets to it, hitting the far stop and bouncing off. It's one bit a dot, thresholded or dithered at the pitch, with a seeded set of stuck discs and a few weak coils that swing late.

Eleven Windows 95 and 98 screensavers (Mystify, 3D Pipes, 3D Maze and eight more) rebuilt as an FFGL source and a matching mask effect. Every saver is a pure function of time and a seed, so nothing drifts with the frame rate, and you can scrub the whole thing and lock it to the beat.

Two FFGL plugins, a source and an effect that plays over your clip, with a one-armed bandit, a roulette wheel, the money wheel, a craps table and the lottery drum, plus chips and coins raining down on a win. Every game is simulated properly, then repainted so it lands on a random result or the one you picked, at exactly Spin Time or on the next beat or bar. The physics never finds out it's been fixed.

Retro console video hardware as an FFGL effect: a real machine's raster, palette and attribute cells, plus scroll-register distortion and glitches that corrupt the indices, so even a machine in the middle of falling over never shows a colour outside its palette. Now with the Amiga: 12-bit registers, Extra Half-Brite and an exact HAM6 encoder.

An FFGL source that draws a tracker's pattern editor and lets the music fill it in. The row cursor runs on the tracker's own clock, four rows a beat at the default Speed of 6, locked to the host's tempo. Each channel owns a band of Resolume's 64-bin spectrum, and an onset in that band writes a note on the current row, with its pitch from the band's peak and its volume as a Cxx effect. After row 3F the cursor wraps round and the next pass writes over the last.

An FFGL effect that loads your clip the way a ZX Spectrum loaded a screen: in screen-memory order, at the baud rate, monochrome first and colour last, with the border striped by the loading signal itself. It's a transition built from an address order rather than a shape, so the venetian-blind thirds nobody designed are just where the bytes go.

Point it at a WAD and Doom becomes a Resolume layer. Composite it, key it, run it through other effects, and MIDI-map the controls onto whatever's already on the desk. On a widescreen composition it plays in true widescreen, showing more of the level instead of stretching the picture. With nothing mapped it plays Doom's own attract demos forever. No game data is included, so bring your own WAD (Freedoom is free and complete). It's licensed GPL-2.0-only rather than the usual MIT, because it ships an engine descended from id Software's Doom source.

An FFGL effect that shows your clip on a split-flap departures board. Every cell is a drum of flaps that can only turn forwards, one flap at a time, at the motor's rate, and every flap in the air is a hinged plate falling under gravity and slapping onto the stop. A change ripples across the board, a step brighter is one flip and a step darker is the whole way round the drum, a moving picture is never finished, and the drum can be printed with tones, a palette or a message.

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

Runs OpenFX plugins (the format DaVinci Resolve uses) inside Resolume Arena and Avenue. Point the app at your OFX folder, choose where the results go and press Start, and it writes one FFGL plugin per OFX plugin, each carrying that plugin's own parameters into Resolume's UI. You don't need a compiler.

A small C++ library for plugins that host something with its own clock, like a game engine, an emulator or a software renderer. It loads a private copy of the source library so two instances stay two instances, pays out the source's clock against elapsed real time so speed and pause are the same mechanism, and presents its frames as a properly letterboxed quad. It needs OpenGL and libdl and nothing else.

An FFGL effect that does to your clip what The X-Files' opening titles did to theirs: a stuttering step-printed picture, a zoom into a photograph until it's all grain, a face pulled long, a hand that glows, a torch in the dark, a cold teal grade and a caption that spells itself out. There's a crime drama's freeze-frame hit in there too, for when one press should stop the frame with a flash and drain it to black and white.

Two FFGL plugins for Resolume: a dish of ferrofluid in a photographer's studio that stands up in spikes on the beat, and an effect that hangs your clip above the same pool and breaks it up in its mirror. Three real fluids off their datasheets, a Helmholtz pair, one coil or three under the dish, and every spike the shape a solver found offline with the full nonlinear magnetostatics, rather than a cone somebody drew. The spikes jump up past onset, hang on below it and lie down at the fold, as the real stuff does.

An FFGL effect that treats your clip as the print on a trading card and puts a holographic foil under it: the holo window behind the art, the reverse holo round it, foil over the whole card, or foil only where the ink is light or dark. None of it's painted on. Every pixel is a little diffraction grating under a lamp, so the colours are the ones a grating really throws at that angle, they run through the spectrum as the card tips, and the ink on top filters them the way printing ink does.

An FFGL effect that gives every pixel of your clip a depth, focuses a lens at one distance and lets the rest fall out of focus the way a fast lens does, with the highlights turning into the aperture's shape: seven-bladed discs, a mirror lens's rings, stars or hearts. The depth can be a floor running to a horizon, distance from a point, brightness, haze, whatever looks like the subject, or a real depth map packed beside the picture, and the focus can follow something a tracker holds on to. Or leave the picture sharp and add only the bokeh, with orbs, lens flare and dirt on the glass in the same aperture.

Two FFGL plugins for Resolume that draw the contour lines of real worlds and sweep a line through them from the lowest ground to the highest, the way a pen plotter draws a map. The Moon, Mars, Earth and six more bodies from their missions' own height maps, twenty-two places on Earth, a world it makes up, or your clip's brightness as the height. Four looks from white ink on black to a survey atlas, and a sweep that can rise, fall, bounce, flood the map like a rising sea or lock to Resolume's bars.

An FFGL effect for Resolume that turns your words, in any font you have installed, into a mask over the clip: the clip through the letters, or the letters cut out of it, on transparency, black, white or a colour. The letters aren't a picture of the text. Every pixel asks the font's own curves whether it's inside a letter, so a word stays sharp whether it fills the frame or you've zoomed a thousand times into one stroke of it.

An FFGL mixer that puts the layer below behind a sheet of glass and this layer on a hidden screen reflecting in it, the way Pepper's ghost has worked since 1862: a Victorian pane, a Musion-style foil or the plastic pyramid people stand on a phone. The sheet reflects what Fresnel says it does at every pixel's angle and lets the rest through, so the ghost only ever adds light, vanishes at Brewster's angle under polarised light, doubles in a thick pane and shimmers on a foil that rings like a drum. A second plugin, SW Pepper Feed, lays a clip out for a real pyramid.

An FFGL effect that forces your clip into 16 colours or fewer, the way an 8-bit machine's screen would have shown it: the Commodore 64, the ZX Spectrum, the NES, the Game Boy, CGA, the Amstrad CPC, PICO-8, teletext or the Amiga's Workbench, a palette you type, or one chosen from the clip. The picture becomes a grid of colour numbers and a small colour table, as it was on the hardware, so a palette swap, a fade and Deluxe Paint's colour cycling are writes to the table while the picture underneath stays exactly where it was.

An FFGL effect that does slit-scan photography to your clip, once a frame: the phone filter that gives everyone a three-foot chin, Trumbull's Stargate corridor from 2001, the Doctor Who title tunnel and the Star Trek warp stretch. None of it's drawn. Each is one long exposure taken while something moves, and the perspective, the lean and the glow at the far end are what a slit, a dolly and an open shutter give you.

An FFGL effect that throws your clip onto a real surface the way a projector would: brick, corrugated sheet, tread plate, drapes, weatherboard, tiles, crumpled paper or a height map of your own. The light leaves a lens at a real place in the room and you watch from somewhere else, so the picture dims with distance and angle, takes the wall's colour, falls into shadow behind the relief and slides over it as you move. A projector, not a texture map.