Everything we've built

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.

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 multitrack recorder that runs entirely in a browser tab. Choose an audio interface and it gives you one track per input, mapped 1:1, streamed straight to a folder on disk as mono WAVs. A continuous pre-roll buffer holds every input as it arrives, so pressing record puts the previous 30 seconds at the head of the take. When a disk stalls, the frames it lost are padded with silence and written into the take's manifest, so a gap costs content and never time — and a generated test signal proves the whole chain without an interface, with a 1 kHz reference at exactly -18 dBFS.

A platform-independent audio cue player for theatre and live events — cues, fades, links, loops and vamps, with a per-cue output routing matrix. Driven by OSC, MIDI, MSC, MMC, Art-Net or sACN.

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.

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.

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.

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

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.

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.

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.

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.

Turns a venue drawing into a d&b ArrayCalc venue file. An ArrayCalc venue is a few dozen parametric planes; a CAD export of the same theatre is tens of thousands of triangles, so the work is the reduction — weld, merge coplanar regions, recover each outline, and write it back as the quads and triangles ArrayCalc actually accepts. It also reads the drawing on the way in: layers named as dimensions, rigging or services are left out, plane types come off the names, banks of separately modelled seats become the audience plane they stand for, and meshed surfaces are re-cut from their own outlines — a seat-by-seat theatre plan lands as 17 objects instead of 3,710, all of it visible and one click from being put back. Imports DXF, glTF, IFC and the usual mesh formats, and there is a Vectorworks plug-in that skips the intermediate file entirely. No 3D model? Drop a PDF or an image of the plan instead: set the scale, click inside a room to detect its outline, and type a height at each corner — level, raked, raised or sunk. It also writes L-Acoustics Soundvision 3D room data, where a surface is a free polygon so an awkward outline goes across whole. The .dbacv format is undocumented; this reproduces a real export byte for byte and has been round-tripped through ArrayCalc itself until every object came back untouched.

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.

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.

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.

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.

A menu-bar tray launcher shell for the local web-server apps in this fleet. Pick a network interface and port, start and stop the server, open the web UI — without each app building its own.

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.

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

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.

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.

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.

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.

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.

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 123 presets 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 OSC control of PDF Presenter.

Bitfocus Companion module for OSC control of the Presentation Commander client.

Bitfocus Companion module: route outputs, recall scenes, blackout, send stage notes and drive next/previous slide from a Stream Deck.

Bitfocus Companion module for RFutils monitoring.

Bitfocus Companion module for OSC control of SimpleCue.

Bitfocus Companion module for the srt-router crosspoint.

Bitfocus Companion module for WebLinked.

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.

Measures how loud the room actually is — from a calibrated measurement microphone or an SPL meter's live output — and applies the ISO 226:2003 equal-loudness correction needed to hold the tonal balance the system was tuned for as the show level moves.

A cross-vendor Dante control bridge: preamp gain and phantom control across Behringer/Midas, Allen & Heath and Yamaha, plus radio-mic telemetry from Shure and Sennheiser.

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.

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

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 Nextcloud app for production teams: build a show from a CSV, the browser or a live Google Sheet, and it creates a folder and upload-only drop link per session, emails each presenter, and can create per-theatre accounts scoped to their own folder.

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.

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.

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.

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.

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.

Snapshots every repo an account owns into per-repo JSON committed to git, and renders a password-gated dashboard from it — because GitHub keeps traffic for 14 days and reports stars and downloads only as a running total.

GL.iNet's self-hosted KVM cloud, extended so the same UI reaches ordinary machines too — VNC, RDP and xpra endpoints alongside the KVM devices it already managed.

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.

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 sound level meter and dual-channel analyser: fractional-octave RTA, spectrograph, time-weighted SPL and as many LEQs as you care to define, plus level history charts, CSV logging, a signal generator and transfer function measurement with phase, coherence and delay finding — on a grid of tiles you lay out yourself.

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.

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.

Discovers and monitors Shure and Sennheiser wireless receivers on the network: AES67 metering, battery and RF status, local headphone cue, and optional Companion-driven Dante routing.

An interface for Waves SuperRack Performer: run the Dugan Automixer across a console's channel direct outs and return the automixed result summed to a single stereo pair, into a group's external input — leaving every insert slot free.

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.

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.

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

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.

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 browser-based installer for LineageOS and other alternative Android systems. It speaks fastboot and ADB over WebUSB, reads the codename, firmware version and lock state off the connected handset, and generates the install procedure for that exact device — the extra partitions it needs, the stock firmware it expects, the unlock command it actually takes. The device data is generated from the LineageOS wiki's own files rather than transcribed from them, so all 733 devices the wiki documents are covered: 554 get a full procedure, and the other 179 are told plainly that no browser can flash them. Files dropped in are hashed in the page and checked against the official SHA-256 for that build before anything is written, and every automated step prints the adb and fastboot commands it stands in for — so it is still a correct, ordered, device-specific command list in a browser without WebUSB. Verified end to end on a Pixel 4a, from bootloader unlock through to a booted LineageOS.

Browse, preview and bulk-download open-source fonts — every Google Fonts family, plus the ones Fontsource carries that Google does not — or hand it a CSV, XML or text list of family names. The files are the complete original TTFs from the google/fonts repository, never the subsetted web versions, and a whole-catalogue pull (about 2.2 GB) streams to disk as one zip with per-platform installers and every family's licence text. Names it cannot find get open stand-ins: Carlito for Calibri, Arimo for Arial, Tinos for Times New Roman, with the same widths. The desktop app installs fonts straight into your user font folder, starts at login in the tray, watches a folder for lists, and takes fonts and lists from an SMB, NFS or WebDAV share — so one folder on a NAS provisions every machine that runs it.

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.

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.

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.

Turns a mixing console show file into documentation an engineer can actually use — a patch list, a specification sheet and a wiring topology diagram, as PDFs. Runs in the browser or on the command line.

A minimal PDF-only presenter: Now/Next view with clickable slide thumbnails and a fullscreen output on the second display, driven by keys, a clicker or OSC. No notes panel, no media, no deck editing.

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.

Turns an Ofcom PMSE licence schedule PDF into Shure Wireless Workbench import files — a documented frequency list, a CSV reference sheet, and an experimental native .shw show file.

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.

Drop in a .pptx and find out which fonts it actually uses, which of those are installed on the machine looking at it, and what to do about the rest. The hard part is that a plain search of the file is wrong: every Office theme carries a script-fallback table naming around thirty CJK and Indic fonts whether or not the deck contains a single such character, so three real presentations report 39, 36 and 9 typefaces where the true answers are 2, 4 and 6. Decks also name faces rather than families — "Helvetica Neue Medium", "Poppins Regular", "Times Roman" — which a naive check calls missing when the font is sitting right there. It resolves both before it says anything. Missing fonts are matched across two catalogues — 1,942 Google Fonts families plus 119 more from Fontsource. The ones that can never be shared — Calibri, Cambria, Arial, Times New Roman — get metric-compatible stand-ins instead, same advance widths, so line breaks hold. Adobe Fonts are named as Adobe Fonts and linked to activate rather than pretended to be fetchable. Anything left goes into a sidecar .zip with per-platform installers. A desktop build installs them outright.

The presentation-laptop half: a bespoke PDF/Keynote/Google Slides engine with dual NDI outputs — Program and Next Slide — driven remotely from the Server.

Converts Keynote, PowerPoint, Google Slides and ODP to PDF with a presenter-notes sidecar, so notes survive the conversion. GUI, CLI, server and a Nextcloud app from one codebase.

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.

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.

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.

A browser-based RF suite for radio mics: WWB/WSM/PMSE file exchange, live Shure and Sennheiser monitoring with headphone cueing, IM-aware coordination, and device programming.

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.

A real-time audio analyser that runs entirely in a browser tab: an RTA from 1/3 to 1/48 octave, a spectrograph sharing its frequency axis, and a full-height meter with peak, RMS, peak hold and broadband Z/A/C. The transform chain is pinned by tests at every size and window, and the built-in pink noise source is the check that it reads level before you trust it about a room.

A lightweight lighting visualiser. Drop in an MVR and it reads the rig straight out of it — fixture positions, patch, and the GDTF definitions embedded alongside, so it knows which channel is pan, how wide the beam opens and whether the colour mixes additively or subtractively. Then feed it Art-Net, sACN or DMX off a USB interface and watch the programming in volumetric haze, from anywhere you care to put the camera. Pixel-mapped fixtures work properly: a wall that declares four template channels across a hundred references is resolved to the three hundred it actually occupies, one DMX slot per pixel. The desktop build takes the live input. There is also a browser demo, which imports and flies the same rig on a built-in look — a demo rather than a hosted edition, because Art-Net and sACN are UDP and a browser cannot receive them.

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.

The software half of a partyline intercom rig: a server that mixes, and endpoints with up to ten keys each. Every key is its own AES67 stream carrying either a partyline bus — minus that endpoint's own voice — or a direct point-to-point path.

Models a stage and a lighting rig and works out the illuminance on the deck before anyone gets to the venue. Build the rig from truss, bars and stands, focus each fixture at a point on the stage and let it resolve the pan and tilt, then read the levels off a heatmap with the beam cones drawn over it. The part worth having is a single toggle between a horizontal plane and a vertical one: a rig can be perfectly even on the floor and flat and shadowless on faces, because overhead light arrives nearly edge-on to a vertical surface, and flipping between the two inverts the ranking of your fixtures. Every fixture carries a badge saying whether its numbers were measured from an imported IES or EULUMDAT file, transcribed from a named datasheet, or synthesised from an archetype — because a lux figure computed from a guess is worth nothing unless you can tell which is which.

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.

Dockerfiles, compose files and Unraid Community Applications templates for the self-hostable apps in this fleet — all generated from two JSON files rather than written by hand.

Injects out-of-tree kernel modules into a SquashFS initrd and writes it to bootable removable media. You supply the image and the modules — useful when an installer doesn't know about your NIC or RAID card.

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.

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.

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.

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.

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.

Moves frequency-coordination data between Shure Wireless Workbench and Sennheiser Wireless Systems Manager. Reads and writes both native formats, reverse-engineered from real exports, plus a generic CSV column mapper.

Zero-added-latency parametric EQ, dynamic EQ with external sidechain, band-isolated harmonic generation and a compressor, with ballistics-accurate metering and a full preset system.