Playing Pixels vs Pressing Play

Image courtesy of ACT Entertainment
(Image courtesy of ACT Entertainment)

The Tyranny of Timelines, or How I Forgot My First Love In The Theater

OK, not really… Because that was my wife Colleen, I was 17, and it was my first job in theater at Trinity Repertory in Providence RI… but that is an entirely different article. But let’s talk about my second love… CONTROL

The timeline promises certainty. It smiles politely and says, "Just tell me what happens next."

But live design doesn't know what happens next. That's the point.

The first time a timeline betrayed me wasn't dramatic. No crash. No blackout. Just that quiet, sinking feeling when the room changed and the show couldn't. The music stretched. The singer lingered. The audience leaned in… and the media stayed exactly where it was told to stay. Frozen in its own certainty.

Lighting never has to do that. Lighting listens.

A lighting rig doesn't care what you meant to do. It cares what you're doing now. HTP until LTP, IYKYK. Palettes exist so you can change your mind without apologizing. Cues exist so you can store intent, not outcomes. A lighting console assumes chaos. It expects the room to fight back. That's why it wins.

And here's what we don't talk about enough: there are thousands of people who think this way. Modern lighting programmers share a cognitive architecture – a common language for time, space, and phenomena refined over decades. Palettes aren't just convenience. They're abstraction layers that let you operate at the right altitude. You're not addressing pixels. You're invoking color, position, texture. The console becomes a vocabulary for spatial poetry, and the fluent speakers are everywhere.

Timeline-based media work has no equivalent. Each project reinvents its organizational logic from scratch. There's no shared language for "shift the emotional temperature of this entire visual field 15% warmer in the time it takes the chord to resolve." Every show starts from zero.

How We Got Here

Somewhere along the way, media forgot it was supposed to be alive.

And I'm partly to blame. In the beginning, I came from the world of light, and my first instinct was to wonder how I might control media from a familiar vernacular. My first discipline was lighting design, and I had become comfortable with the idea of lighting control. The philosophy, the process, the devices.  And as I began to dabble with integrating video playback, my first instinct was to probe how I might control it in the same way. Then Colleen and I started learning 3D animation, and Avid Media Composer, and Adobe After Effects, and…

We started borrowing tools from postproduction and pretending they were instruments. We taught designers to edit instead of perform. We pushed our toolmakers into adopting UI from post-production instead of production. We replaced reflex with rehearsal and called it progress.

Timelines multiplied. Layers stacked. The playhead became a dictator with a very small imagination. We never allowed ourselves a moment to say "wait—let's remember why we got here" and consider what was actually best for what we were doing.

The Gantt chart had won. And nobody noticed, because Gantt charts look so professional. They promise that if you plan thoroughly enough, you can eliminate uncertainty. You can decompose the complexity of live spatial expression into sequential tasks with dependencies – like building a house.

But live performance isn't construction. It's conversation. And conversations don't have playheads.

The Sock Puppet Problem

"But wait," I hear you saying. "I AM controlling my media server with DMX."

Are you though?

What you're probably controlling is a sock puppet (maybe figuratively, or perhaps literally). A marionette with a scant handful of strings. You're not manipulating the media – you're triggering someone else's decisions. Start this timeline. Crossfade to that one. Adjust the global intensity. 

I'm not interested in triggering timelines. I'm interested in triggering time itself. Delaying it. Stretching it. Compressing it. Riding alongside it like a surfer finding the pocket of a wave. The timeline treats time as a rail you're locked onto. The console treats time as a material you can shape.

A timeline is a score that only plays one way. A console is an instrument.

The difference isn't technical. It's philosophical. One assumes the future is knowable and your job is to predict it. The other assumes the future is emergent and your job is to respond to it.

When a great LD rides a bump they didn't plan, catches a moment the director didn't choreograph, feels the room exhale and pulls the intensity down with it – that's not reproducible in a timeline. It's not even representable in a timeline. The timeline has no parameter for "trust your hands."

What Is Content Now?

And here's where it gets interesting: what even is content now?

The old model was simple. Render your pixels in advance. Package them into video files. Stack them in a timeline. Press play. Content was a deliverable—a thing you made before the show, then faithfully reproduced during it.

That model is dying.

Real-time engines are eating pre-rendered content alive. Unreal. Notch. TouchDesigner. The "media" in a modern live event isn't a video file – it's a living scene with hundreds, thousands of exposed parameters. Particle densities. Camera positions. Material properties. Lighting rigs inside the engine responding to lighting rigs outside it. Procedural systems generating visual complexity that literally didn't exist until the moment of playback.

You can't timeline your way through that. There's nothing to render in advance. The content is the parameter space.

So ask yourself: what control paradigm was built from first principles to wrangle arbitrary collections of ad-hoc parameters from devices that didn't exist when the software was written?

Lighting Consoles

That's what fixture profiles are. A lighting console doesn't know what a Robe MegaPointe is until you tell it. It doesn't know what an Ayrton Perseo is, or a GLP impression, or whatever weird LED thing someone bolted together in a warehouse last week. You build a profile. You expose the parameters. And suddenly that device—whatever it is, whatever it does – can be grouped into palettes, modulated by phasers, sequenced in cue stacks, and surfaced in custom UI layouts.

There's no reason that device can't be an Unreal scene.

Expose your parameters. Color temperature of the virtual sun. Intensity of the volumetric fog. Speed of the particle system. Camera FOV. Post-process bloom. All of it – addressable, groupable, effectible. Thirty virtual lighting fixtures in the game engine, running in a phaser alongside thirty real fixtures in the room. One selection. One encoder. One intent, expressed across the boundary between physical and virtual space.

What other control paradigm was designed to flex like that? What other system assumes it will encounter devices it's never seen and gives you the tools to assimilate them into a coherent operational grammar?

DMX Isn't Nostalgia. It's Ergonomics.

Please know that I use "DMX" interchangeably with modern networked lighting control. I'm not trapped in a 5-pin mindset. I'm talking about a signal path, a process execution path, a way of thinking about human agency and machine response.

It's the shortest path between instinct and impact.

The timeline assumes content is fixed and time is the variable you're navigating.

The console assumes everything is variable—and time is just another parameter you can put on a fader.

The World We're Growing Into

We're growing into a world that demands this.

Real-time. Immersive. Responsive. Increasingly AI-mediated. The experiences we're building don't just tolerate improvisation – they require it. When the content itself is generative, when the environment reacts to the audience, when machine learning systems are adjusting visual fields based on sensor input and emotional inference... you cannot pre-plan that. You can only steer it.

Timelines take time. They need it in advance. They consume it during prep so they can regurgitate it during performance.

Lighting consoles play with time. They treat the present moment as the only moment that matters, and they give you the tools to shape it as it arrives.

When media parameters live on faders, pixels stop being precious. They become playable. You stop asking "Can I?" and start asking "What if?" The show stops being a fragile sequence and becomes a living system – responsive to the room, to the performer, to the machine, to the accidental genius that only happens when humans are allowed to improvise.

This isn't about rejecting timelines. Editorial belongs in prep. Pre-visualization belongs in prep. The hard work of building the parameter space and designing the palettes and programming the building blocks – that's prep.

But authority belongs in the room. In the moment. In the hands of someone who can feel the room breathe.

Commanding all the pixels doesn't mean controlling every outcome. It means refusing to surrender creative agency to a progress bar—especially now, when the progress bar can't even see what's coming next.

Live means alive.

Alive means responsive.

Responsive means DMX-first.

And once you feel that freedom—once you've ridden a phaser across a thousand real-time parameters while the content itself is being generated by systems that don't know what they'll make until they make it—the timeline doesn't just look different.

It looks like a relic.


Bob Bonniol is the Chief Innovation Officer at ACT Entertainment. This is the first in his series exploring what it means to command all the pixels.