DMXing
A working lab for live lighting: QLC+ show pages generated from code, built for busking real gigs and for venue staff to run.
The Challenge
The Problem
Programming DMX lighting cues is tedious and technical. Wondered if AI could help translate 'make it look like a sunset' into actual fixture commands.
Why I Took This On
Pure curiosity. Seemed impossible, which made it interesting.
Constraints
QLC+ has a specific XML format for scenes and cues. AI output has to be precise or it breaks.
The Process
Initial Approach
Fed Claude the QLC+ documentation and tried direct generation of XML files.
What Went Wrong
Raw XML generation was too error-prone. One wrong character and the whole file corrupts.
Breakthroughs
Built a translation layer that converts AI suggestions into validated QLC+ format. AI handles creative intent, code handles precision.
What I Learned
Skills Gained
Unexpected Discoveries
AI is surprisingly good at understanding lighting mood words. Less good at precise technical output without scaffolding.
What I'd Do Differently
Would have built the validation layer first instead of debugging corrupted XML files.
Where It Stands Now
Current State
Working prototype. Can generate basic scenes and chases from descriptions.
What's Next
Want to add beat detection for music-reactive cue generation.
The Bigger Picture
Direct application to venue work. If this matures, it dramatically speeds up show programming.
The Impact
Personal Impact
A potentially game-changing tool for live production work. Also a lot of DMX knowledge I didn't have before.
Build Log
First night busking the whole office rig from the new engine's on-screen console, then a round of fixes from that run: moving heads that turn on with any pick, sliders for strobe, zoom, focus and gobo spin, and colors limited to what each fixture can really show.
The new lighting engine learned to busk: pick where in the room, then a color or an effect, and one tap pulls every running effect back onto the beat. Built and tested on the PC, ready for its first night on the rig.
The lighting rulebook now picks its rules by style of presentation (song show, live band, DJ set, installation, theater, speech), with new research on DJ sets, experience rooms and musicals folded in: 130 checkable rules.
Crash recovery for live playback: kill the lighting process mid-song and the look holds while the song plays on, with the cues back in under half a second; kill the audio and the song resumes where it stopped.
The new lighting engine played its first song: Renegade's show, captured from QLC+ and played back with the audio and the lights on one clock, every section on time, with QLC+ closed.
The words a light show is described in (breathe, stab, walk, rise and the rest) are now data: each is a vector on measurable axes, backed by a section that ran on the rig and the verdict it got, so a mood means the same thing every time.
Six-stem source separation on the office GPU now names which instrument leads every section of a song in about twelve seconds, which is what the light-show planner needs to find the solos the old analyzer missed.
A custom operator surface for the office rig: a React console with a stage map drawn from the truss drawing, console-style buttons with LED state dots, and a client for QLC+'s own web API, so the engine keeps doing the lighting and the page only has to look right.
Turned Titanium into a timed QLC+ Show Manager show, every fixture choreographed on the timeline from a written plan, and ran it live on the office rig.
Built a song analysis pipeline that pulls a beat-locked tempo grid, downbeats, section boundaries and an energy curve out of any audio file: the groundwork for lighting a song fixture by fixture.
Modelled the office lighting rig and a venue stage in QLC+'s 3D view from real measurements, and wrote new fixture definitions from manufacturer DMX tables, so pages can be designed and checked on screen before they reach real lights.
Set up two AI sessions to share one codebase safely: one edits and tests against the lights, the other commits and keeps the repo in order, with a shared handoff file and a check of every claim against git.
Ran a multi-agent research sweep on live lighting busking: six parallel tracks plus a sweep for new ideas, each checked by an independent reviewer. It produced a reference of techniques, pitfalls and eight ways to lay out a busking control surface, sourced and labelled down to the claim.
Turned a folder of lighting experiments into a structured lab: a private repo organised by rig, Python generators that build QLC+ show files from code, and an installer that sets up any machine's fixture library from the repo.
