What a Stage Door Play Script Actually Does
A Stage Door Play Script is a piece of automation code that handles the technical cue running for a live theater production. Most people in the industry use them with some combination of QLab, StageDirector, or bare-metal Python scripts that talk directly to lighting consoles and audio interfaces over DMX, MIDI, or OSC. The point isn't fancy design — it's making sure that when the show runs at 2 PM on a Tuesday and the stage manager is tired, the cues still fire in the right order. I wrote one for a regional theater run last year. Our venue didn't have a digital console, just an analog board with a motorized fader section connected through a custom relay box. The script ran on a Raspberry Pi hooked to the console's cue port and an Arduino managing the fly rail relays. It read a cue sheet in CSV, fired each cue on time, and sent position updates to the stage manager's headset through a simple tone sequence. Saved us from missing three cues in the first act that would have been impossible to catch otherwise.
Stage Door Play Script Structure
The script needs to handle three things: reading the cue data, executing cues with accurate timing, and reporting back status. The basic architecture looks like this. A cue file — usually JSON or CSV — contains cue numbers, timings, and actions. Each action maps to a hardware command: dimmer level, sound playback, trap activation, blackout, and so on. The main loop reads the current cue position from the stage manager's call board input or from an internal timer, then executes the corresponding commands with a small delay buffer to account for hardware response time. Here is a minimal example of what the cue file format looks like in practice: {
"show_name": "The Cherry Orchard", "act": 1, "cues": [
Get the Full Details
{"number": 1, "time": "00:02:15", "action": "blackout", "target": "main_bat"}, {"number": 2, "time": "00:02:30", "action": "light", "target": "spot_3", "level": 85}, {"number": 3, "time": "00:03:00", "action": "sound", "target": "sfx_rain", "fade": 3.0},
{"number": 4, "time": "00:07:45", "action": "fly", "target": "act_1_bg", "position": "down"}] } The timer component is the hardest part. If you are building this from scratch, do not try to use Python's time.sleep() for cue scheduling. Hardware doesn't respect it. Use a threading-based scheduler or a library like schedule with a high-resolution clock. My rule of thumb is that your timing tolerance should be under 150 milliseconds for anything that isn't a simple fade. Anything faster and the audience will notice the gap between the light change and the actor's mark.
Getting It Running
First, pick your hardware interface. If you have a digital console like a Strand Lighting Frame or a GrandMA2, you can talk to it over ArtNet or sACN. Install the appropriate library — python-artnet or netsend for Python projects. If you are working with analog gear and relays, an Arduino or Teensy microcontroller will handle the discrete on/off commands. I usually wire the relay board to GPIO pins on the Pi and use pyserial to send commands from the script to the board. Second, set up your cue file parser. Keep it separate from your execution engine. I use a simple YAML loader that validates the file on startup and prints any errors before the show begins. This catches typos in cue numbers or missing target references before you are five minutes into a performance. Third, build in a manual override. The script should always have a physical button or a keyboard shortcut that lets the stage manager advance or hold cues manually. In my experience, the most common failure mode is a hardware glitch mid-show — a loose cable, a power drop, a network hiccup — and having no way to take control back instantly is unacceptable. I wired a simple arcade button to the Pi that switches the script into manual passthrough mode. One press and the SM is calling every cue by voice again. Took about 20 minutes to set up and has saved me twice already.
Common Pitfalls
People tend to overcomplicate these scripts. The instinct is to add features: automated scene transitions, real-time actor tracking, integration with social media for audience notifications. None of it matters if the core cue firing is unreliable. Start with the basics and make them bulletproof. A script that reliably fires 50 cues in order is better than one that attempts 200 and misses three of them. Another mistake is not accounting for hardware latency. DMX channels don't change instantly. A dimmer ramp from 0 to full takes time depending on the fixture type and dimmer profile. Your script should include per-cue delay values that reflect actual hardware behavior, not theoretical response times. Measure this during tech week with a stopwatch if you have to. I once had a cue where the script fired a lighting change and a sound effect simultaneously, but the PAR cans took 400ms to reach full intensity while the audio hit immediately. The effect looked sloppy. Adding a 0.4 second pre-delay to the audio cue fixed it completely. File path issues are the third big problem. Scripts that hardcode absolute paths break as soon as you move them to a different machine or directory structure. Use relative paths or environment variables. I set a SHOW_ROOT environment variable that points to the show folder, and everything inside the script references that. Makes moving productions between venues painless.
Where This Approach Breaks Down
A Stage Door Play Script is not a replacement for a professional show control system like Show Designer or QLab 3+ in a professional house. If you are running a Broadway-level production with 800 cues, wireless followspots, and motorized scenery, this kind of DIY approach won't hold up. The scripts lack the redundancy, the hardware failover, and the certification that those systems provide. Use it for small theaters, black box venues, educational productions, or situations where budget doesn't allow for commercial show control software. Also, these scripts require someone who understands both the code and the theater to maintain them. If the person who wrote the script leaves town and nobody else knows how it works, you are in trouble the moment something breaks. Document everything. Comment the code. Leave the cue files readable. A stage manager who has never seen Python should be able to open your cue file and understand what each line does. One more thing nobody warns you about: power management. The Pi or laptop running the script needs a clean power supply. A brownout can cause the script to crash mid-show, and if your hardware interface loses its control signal, everything goes dead. I started using a small UPS for the Raspberry Pi after a power fluctuation took down our show during act two. Cost about forty dollars. Worth every penny.
