Video

A browser dashboard to monitor and control a fleet of Blackmagic ATEM switchers, styled after the BMD multiviewer. Ships as a desktop tray app too.

Provision a whole fleet of ATEM switchers at once. Model-aware config forms export loadable XML plus a media folder, or apply live over the network — instead of one unit at a time on a flight case at 02:00.

Control for ATEM Mini Pro/Extreme ISO with something the hardware doesn't give you: a software-composited SuperSource/DVE preview, built by capturing the switcher's own multiview over UVC. Touchscreen operator UI plus a Companion module.

A crosspoint router matrix over a fleet of Blackmagic ATEM switchers — sources across the top, destinations down the side, one click to route — which also serves the Videohub Ethernet Protocol, one server per switcher, so hardware router panels, Companion and a media server's own matrix driver all reach the same crosspoints. For a redundant rig it watches the main media server and fires a salvo when it stops answering.

Video scopes arranged around a live ATEM multiview. Waveform, vectorscope, histogram, false colour, zebras and focus peaking on any multiview window — program and preview included — with sources named live from the switcher's own multiviewer config. Desktop app and browser build.

Scaffolds an entire DaVinci Resolve project — theatre and day bins, per-session timelines, imported media and smart-bin recipes — from the same session CSV that drives the file-drop workflow.

Adds seven things to an Analog Way switcher's own Web RCS — LivePremier, and since 0.6.0 Midra 4K and Alta 4K too: a VPU resource map, a lighting-desk command line, a theatre cue stack, a memories list across every bank, a layer-properties panel generated from the device's own catalogue, MIDI control-surface mapping, audio routing from the command line, and arithmetic in numeric fields — type 1080-80 into a layer width and get 1000. It runs as a local proxy, so you browse to it instead of to the switcher and the extra panels are simply there, drawn in the vendor's own design language.

A lighting-desk command line for Analog Way switchers — LivePremier, and since 1.4.0 Midra 4K and Alta 4K as a language core other apps embed — with their audio routed, not patched, since 1.5.0. Type “Recall Screen 1 Memory 5” and press Enter — grandMA3's grammar rules with the switcher's own vocabulary. It shows the exact device paths a command produces before sending anything, and reports an empty memory as empty rather than as success. The memory paths were verified leaf by leaf on a physical Aquilon C, and the Midra spellings on a live Pulse 4K.

Every layer on an Analog Way LivePremier costs physical mixing hardware, and the frame knows exactly where that hardware went. This reads the allocation back and draws the whole chassis on one screen — each VPU as the 8x8 field of links the manual draws it as, every layer's bar as wide as the outputs it spans and as tall as its capacity. It reads and never writes.

Maps MIDI and OSC control surfaces onto an Analog Way LivePremier: faders to layer opacity, encoders to size and position, buttons to select layers, apply sources and switch keying. Bidirectional, so motor faders track the device, LED rings follow encoders and X-Touch scribble strips name the layer each strip is pointed at. Read-only mode is enforced by the client having no write path at all, not by a flag.

A modern control surface for Analog Way Midra and LiveCore series video processors. Its Workspace puts sources, every screen and memories on one window-filling page — build in program, preview or both at once — backed by a graphical layer editor, memories, takes, a multiviewer/confidence-output designer, EDID writer and a full variable inspector.

A reference for the TCP control protocol of Analog Way Midra and LiveCore series video processors — the wire format, the variable model, and the complete variable tables. Documentation only.

A live-events media server built on CasparCG — screens on a canvas, frame-accurate cues, a media library, GDD template forms and a trigger grid, all in a browser. Verified against a real CasparCG 2.5.0.

Renders any web page offscreen through Chromium at a broadcast raster and rate, then sends it to DeckLink and AJA over SDI, to the network as NDI, OMT and RTMP/SRT, into Resolume or TouchDesigner over Syphon and Spout, and fullscreen to a GPU-attached display — every output taking the same frame. It can run several such pipelines at once, each with its own browser, clock and raster, so a page that hangs on one feed cannot touch the others. The engine clocks the browser one frame at a time rather than letting it paint on its own timer, so 50 ticks a second really is 50 paints. Settings, live diagnostics and an interactive preview are all in the browser, so a rack machine needs nothing but an HTTP port.

Master control for a presentation room: a real-time NDI video matrix router, layered scene compositor, presenter-notes hub, and a Control Surface with a JSON-RPC automation API.

A broadcast-router-style crosspoint for SRT: any number of inputs and outputs, each output live-switchable to one source, added and removed at runtime from a web UI. Pure relay, no transcode. NDI transport included.

One web UI for a fleet of BirdDog Play NDI/SRT decoders: LAN discovery, tag-based grouping, full BirdUI-parity settings per device, and batch edits across a whole group.

A BirdDog PLAY is an NDI decoder with no way in from outside the room it is sitting in. This builds an installable firmware package that adds one: an SSH key, Tailscale, and an NDI KVM endpoint that turns the keyboard and mouse on the PLAY's USB port into control of whatever machine it is displaying. The surprise is that it needs nothing from you but a public key — the stock updater runs a script from the uploaded archive as root with no signature check, so a valid package is an ordinary gzip'd tar and there is nothing to decrypt. That means no upload, no vendor keys, and the whole thing assembles in the browser: tar, gzip and SHA-256 are native APIs now. The installer is readable bash that refuses to run on the wrong hardware, stays off the recovery path, and cannot reach the kernel or bootloader. Confirmed on a real unit — Tailscale carries 195 Mbps over userspace networking, and the KVM agent drove a Windows machine using only the free NDI SDK.

A firmware patch for the BirdDog PLAY that adds a Tailscale panel to the System page of the decoder's own web UI, so a unit joins a tailnet from a browser instead of over SSH. It is the other half of the PLAY Patcher: that installs Tailscale but deliberately bakes in no auth key, because a key in a file the browser hands you is a key in cleartext — which left every patched unit installed but not signed in. Settings go through Tailscale's set command rather than up, so changing one preference does not silently reset the rest, and the panel declines to offer exit-node and subnet-route switches this kernel cannot honour: there is no TUN device, so Tailscale runs in userspace networking. Reads are open; writes are gated on a live birdUI session, because an open Tailscale API would let anyone on the LAN join the box to a tailnet of their own.

A firmware patch that adds USB to the source list on a BirdDog PLAY, so the decoder plays video, stills and PDFs off a stick straight to its HDMI output — in order or shuffled, looping, hardware-decoded. The decoder already had everything needed for it and shipped none of it: the media stack is on the box, nothing automounts, and the stock web UI validates the source name against a list USB is not on. So the patch mounts the stick itself, always read-only because people pull these without ejecting, and intercepts the source dropdown rather than trying to teach the vendor's handler a new word — which means the unit stays configured for NDI underneath and switching back is instant. exFAT works without touching the kernel, via FUSE. PDFs render through PDFium.

A replacement operating system for the BirdDog PLAY that turns it into a Bitfocus Companion appliance: the Companion server, its admin interface on the unit's own HDMI output, and USB control surfaces plugged into its port. It is not a patch — it replaces the firmware, so the unit stops being an NDI decoder until it is flashed back. Only two partitions change, which leaves both recovery paths intact. 808 Companion modules ship in the image, so it works with no network on first boot.

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. macOS universal and Windows x64, plus a Linux OpenFX build.

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

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

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, press Start: it writes one FFGL plugin per OFX plugin, each carrying that plugin's real parameters into Resolume's own UI. No compiler needed.

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

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.

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.

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.

Four FFGL sources that draw the stereo and surround field as sonar-style displays rather than meters — where the energy is 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 offers a plugin nothing but a mono magnitude spectrum and three of the four cannot be drawn from that.

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

An aspect ratio, pixel pitch and display geometry calculator that runs entirely in the browser. Resolution × pixel pitch = physical size, so any two of the three give the third — and it names the ratio the way the trade does, telling you that 3440×1440 is 21:9 rather than 43:18, and that 1366×768 is 0.049% off 16:9 rather than pretending it is exact. It sizes PowerPoint slides on the same arithmetic, working around the 56-inch slide limit and pointing out when the better answer is to leave the deck alone and raise the export DPI.

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.

Three test programs — a moving test card, a controller mapping tester and an overscan display — built from source for as many consoles as have a toolchain in Homebrew. For people who care about the video path rather than emulation accuracy.

A browser page that flashes a BirdDog PLAY in recovery mode over WebUSB, and can inject a firmware package into the image on the way so the unit installs it by itself on first boot. It is the counterpart to the PLAY Patcher: the Patcher builds a package for a working unit, this one is for a unit that needs putting back.

A projector edge-blend calculator that runs entirely in the browser. Flat or cylindrical canvas, any array, and the solver closes the array on the screen exactly — then reports the system resolution, the doubled and quad-covered overlap you pay for twice, the lens needed per position, a PDF report and a Resolume Arena advanced-output file.

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.

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 is already on the desk. Ships 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 — 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.

Bitfocus Companion module for animATEM.

Bitfocus Companion module for Atem Overseer fleets.

Bitfocus Companion module for the BlackMatrix crosspoint router.

Bitfocus Companion module for caspar-AV shows.

Bitfocus Companion module for flock decoder fleets.

Bitfocus Companion module for Kestrel — drive region-to-output routing from a Stream Deck.

Bitfocus Companion module for Analog Way LivePremier, driven by Mynah command syntax. One action takes any command, and a library of well over a hundred presets, plus a command builder, populates a Stream Deck with memory recalls, takes and stores.

Bitfocus Companion module for Analog Way LiveCore and Midra video processors.

Bitfocus Companion module for the srt-router crosspoint.

Bitfocus Companion module for WebLinked.

Falling columns of characters, as an FFGL source and a matching effect. Reads its own generated code, four public domain books, or any text file you point it at, in any installed font.

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 rather than sixty-four doing the same thing at once.

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.

An NDI, OMT, SRT and ST 2110 endpoint in both directions, with screen capture in and SDI, Syphon and shared-surface out — all wired through one crosspoint.

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 the whole thing can be scrubbed and beat-locked.

Takes a single video input — typically a locked-off wide of a stage — lets you draw any number of regions of interest on it, and sends each region back out of a Blackmagic DeckLink, cropped and scaled to the output raster.

A desktop show file library for video switchers — Barco Event Master (E2, S3-4K, EX, Encore3) and Analog Way LivePremier (Aquilon), with Midra 4K and Alta 4K read as well. Every show is kept with a version history and the vendor file it came from; the patch, the screens, the layers and the presets are drawn to scale; it writes PDF documentation, test patterns, multiviewer layouts and Bitfocus Companion pages; it converts a show between platforms with a report of what carried, what was adapted and what was dropped; and it pulls from and pushes to the live hardware.

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 nothing a failing machine shows is ever outside its palette.

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.

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

Builds an EDID from a resolution and a refresh rate, or lets you edit every field of one by hand, entirely in the browser. Then it does the part that usually costs an afternoon: works out the smallest HDMI or DisplayPort version that carries the mode, and checks it against twenty-one models of event processor — answering yes, no, or which input capacity mode you would have to go and configure first.

Neon synthwave strokes as one FFGL effect with two engines: trace the clip's outlines as glowing tubes that can break away from the real geometry, or generate synthwave paths outright — the perspective grid with the striped sun, tunnels, circuits, skylines, and the routed audio as an oscilloscope.

An FFGL effect that turns a clip into ink — continuous, closed strokes on paper rather than a glowing outline. Most edge effects ask how fast tone is changing at each pixel, which gives a magnitude with no memory 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 survives and one that fired on its own does not.

A standalone FFGL host with NDI, OMT, Syphon and DeckLink I/O: route a source out of your mixer, through a chain of FFGL plugins on the GPU, and back in.

A browser tool for designing LED video walls: lay out cabinets, add NovaStar or Brompton processors, wire the ports, and see each port's load and headroom. The capacity model accounts for the power-of-two packing controllers actually use, so it reproduces the manufacturers' published per-port figures rather than overstating them.

One web UI for a fleet of WebLinked instances: tag them into groups, fan any WebLinked command out to a group or the whole fleet over OSC, and watch each instance's real state come back over HTTP. A lighting desk or cue stack can drive the same groups with one OSC message, reusing WebLinked's own verbs so an existing button is retargeted by editing the front of the address.

Waveform, vectorscope, histogram and picture assist as one FFGL effect. Drop it on a layer and it measures what is arriving there — either replacing the picture or sitting over it in a corner.

Generates test patterns for every physical output in a show, from the file that already describes the outputs. Import a Resolume advanced output, a Pixel Peeker wall or a Blend Calc array and get one PNG per output at that output's exact raster — or a single composition-sized image with every output's region labelled, which proves the output map is what you think it is.

Builds the labelled source thumbnails an Eventmaster or an RCS2 shows on its multiviewer, for a whole rig at once. Type or paste the source list, give each one an icon, a size and a colour, and download a ZIP with one image per source named after it — plus a manifest matching file to source. Runs entirely in the browser.

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.

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.

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

Reads the Resolume Advanced Output slice map that drives the real wall, receives Resolume's outputs over NDI, and composites them onto a virtual reconstruction of the rig. Drive that to connected monitors as a stand-in wall, or view it as 3D previz of the set.

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.

Oil, water, alcohol and dye 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 effect that performs the shot where the camera tracks backwards while the lens zooms in, so one surface stays exactly the size it was and everything at any other distance moves. It can invent the depth it needs, so it works on any clip — or read a real depth map out of the picture.

An optional desktop client for the Stoatworks software — plugins, tools, applications and Companion modules. Shows what you have installed and what has an update, and installs each one in whichever formats you use: FFGL for Resolume, OpenFX for Resolve, After Effects, VST3 and Audio Units for a DAW. It keeps itself up to date too. No account, and nothing sent anywhere.

WebLinked in a container: renders a web page offscreen at a broadcast raster and exact frame rate and sends it out as NDI — no display, no card, no desktop.

Describe a show — the screens and their canvases, the layers on each, every source and every destination — and it works out which switchers will actually take it. Not whether the input count adds up, which is the question a spreadsheet answers and the one that gets people caught out, but whether there is a physical plug of the right type and capability for every signal, whether the layer budget covers the layers as each manufacturer counts them, and whether the canvas fits. Thirty-seven machines checked, then a wiring topology proposed for each one that fits.

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 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.

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.

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.

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 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.

Generate correctly sized, themed PowerPoint templates and test decks for an LED wall. Type the wall's resolution and it works out a slide the application will actually accept: PowerPoint caps a slide edge at 56 inches, which is a schema limit rather than a fussy dialog, so a 7680 × 1080 wall wants an 80-inch slide it will not make. The answer is to build at half size and export at 2× — and the build scale is always a whole number or a whole reciprocal, because "build at half and export at 200%" is an instruction a person can follow at 2 a.m. and "build at 1/2.37" is not. Keynote's limits are different and were measured by asking Keynote until it refused: 8192 pt against PowerPoint's 4032, so the same wall it simply holds at 1:1. Themes carry the event's own colours, fonts, logo and background, and the optional test deck renders its patterns at the wall's exact raster. Everything happens in the browser — there is no backend, so a client's unannounced logo has nowhere to be uploaded to.

Lay out LED walls and projection surfaces with their real physical dimensions and resolutions, say how far apart they are, and it works out the composite canvas including the blank pixels in the gaps — so content laid out across the array accounts for the space between the screens as though it were pixel surface, and a graphic crossing the stage disappears behind each gap instead of jumping. Out comes the canvas size, the slice rectangles with the gap offsets already applied, a Resolume Arena advanced-output file, a guide plate at exactly the canvas resolution, PowerPoint slide geometry and a starter deck, CSV, and a PDF report with a scale plan.

Drop a recording, set a threshold and a minimum gap, and watch the silences shade red on a loudness waveform. Out comes a cut-list EDL that DaVinci Resolve imports as the ripple-deleted timeline, a marker EDL to review the silences before cutting anything, an FCPXML for Premiere and Final Cut, a CSV, an ffmpeg command — or the cut file itself, rendered in the browser with its own hardware H.264 and AAC codecs and streamed straight to disk. Reads the frame rate and the start timecode from the file's own timecode track. Runs entirely in the browser.

A tray tool that keeps a Resolume show on DXV. Point it at a folder and anything dropped there is probed and, if it is not already DXV, sent to Resolume Alley to be converted. Point it at a running Arena or Avenue and it finds the clips that are still h264, converts them, and swaps the converted file into the composition in place — keeping in and out points and clip effects, and skipping any clip that is currently playing until it stops. The conversion is done by Alley itself, because there is no DXV encoder in ffmpeg and Alley is the only way to produce one.

Work out the pitch compensation an Analog Way LivePremier needs when one screen spans LED walls of different pixel pitches. Type each output group's raster and its pitch — or its measured size, and let the pitch fall out — and get the H and V ratios to type into Web RCS, the canvas footprint each group will take, the screen canvas that results, and the millimetres the device's three-decimal field costs you at the far edge of each wall. Runs entirely in the browser: no account, no backend, and a client's set design has nowhere to leak to.