GITNUXSOFTWARE REVIEW
Art & DesignTop 10 Best Stage Light Control Software of 2026
Stage light control software roundup comparing Lightkey, Daslight, and Millumin for venue tech teams, with tradeoffs to weigh when shortlisting tools.
How we ranked these tools
Vendors set the topic, but our editors set the inclusion criteria and the evaluation framework before research starts.
Agents extract product evidence with provenance, then collect written reviews and transcribe video reviews and podcasts.
Framework: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page. This does not influence our reviews. Editorial policy
Lightkey is the best pick for SMB venues that need cue-driven shows stay consistent across networked universes, because its timeline-style cue editing stays linked to patch mapping so channel changes flow reliably into playback, while Millumin suits creative teams who want visuals to drive lighting via a media-parameter mapped timeline with OSC triggering.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Lightkey
Timeline-style cue editing linked to patch mapping so channel changes propagate into playback reliably.
Best for: Fits when venues need repeatable cue-driven shows with network distribution across universes.
Daslight
Editor pickIntegrated offline editing that feeds the same cue stack used for live playback.
Best for: Fits when lighting operators need offline-to-live continuity without heavy external automation.
Millumin
Editor pickMedia-parameter mapping lets visuals drive fixture parameters in the same timeline, reducing handoff between creative and lighting control.
Best for: Fits when shows need visual-driven lighting playback with external OSC triggering and fast look changes.
Comparison Table
Lightkey
SMBLightkey is Mac-based DMX lighting control software for live shows, clubs, churches, and small stages.
Timeline-style cue editing linked to patch mapping so channel changes propagate into playback reliably.
Lightkey is a browser-driven stage lighting control environment that centers on building cue sequences and managing playback states for live shows. Fixture setup is handled through a patch-oriented workflow, with named fixtures and parameter mappings that translate show intent into outgoing channel values. For synchronization workflows, it supports external timecode and transport-style triggering so cue playback can align to video or audio systems. For operators who need operator-level speed, it also includes grouping and palette-style reuse patterns for common looks and channel sets.
A key tradeoff is that Lightkey’s control model stays closer to cue playback and timeline editing than deep console-style programming patterns. In practice, it fits venues where shows are delivered as repeatable sequences and the operator needs quick editing for small changes between runs. It is also a strong match when the system must interoperate with a network lighting distribution plan across multiple universes.
- +Cue stack plus timeline editing for fast show iteration
- +Patch workflow that keeps fixture mapping and playback aligned
- +Network output support with per-universe routing controls
- +Grouping and palette-style reuse reduces repeated programming
- –Advanced console-style programming workflows need extra planning
- –Large fixture libraries can feel slow during heavy editing
Touring show operators
Quick cue edits between performances
Faster updates between runs
Venue technical directors
Network lighting distribution planning
Fewer addressing mismatches
Show 1 more scenario
Integrators
Automated show triggering
Tighter audio and video sync
Installers align cue playback with external timing sources for consistent cross-media synchronization.
Best for: Fits when venues need repeatable cue-driven shows with network distribution across universes.
Daslight
SMBDaslight provides DMX lighting control software and interfaces for live events, venues, and mobile productions.
Integrated offline editing that feeds the same cue stack used for live playback.
Daslight is commonly used when a lighting operator wants a single application for patching fixtures, building cue sequences, and running the show. Cue creation centers on a timeline-style concept and a cue stack workflow, which helps organize transitions and repeated looks across the show. Fixture profiles and parameter mapping support practical day-to-day programming, including multi-parameter channels and group-based handling during performance.
A tradeoff appears in how deeper automation and complex integrations depend on the operator’s environment and configuration choices. Daslight fits situations where the production needs fast live adjustments and consistent cue execution, but it is less ideal when the requirement is heavy external orchestration through a wide API surface. A common usage situation is a small to mid-size rig where the patch list stays stable and the operator iterates on looks using the offline editing path before the show run.
- +Cue stack workflow supports repeatable show structure
- +Offline editing and live playback stay in one tool
- +Fixture patching and parameter mapping reduce programming friction
- +Live performance controls support fast look changes
- –Deep external automation depends on configuration discipline
- –Advanced multi-system show orchestration can require extra glue work
Stage lighting operators
Run cue stacks during rehearsals
Fewer last-minute changes
Small production teams
Maintain a stable fixture patch list
Faster programming cycles
Show 1 more scenario
Live event programmers
Busk transitions between crowd moments
More consistent audience timing
Programmable performance controls let the operator refine timing and intensity on the fly.
Best for: Fits when lighting operators need offline-to-live continuity without heavy external automation.
Millumin
vertical specialistMac show control software for video, lighting, audio, MIDI, OSC, and timeline-based stage playback.
Media-parameter mapping lets visuals drive fixture parameters in the same timeline, reducing handoff between creative and lighting control.
Millumin is a visual stage lighting control software focused on media-driven workflows and real-time show playback. It mixes timeline-based cue control with a patch layer built around fixtures and parameters, then maps visuals to output for stage and installations.
Its workflow is designed around creating and running looks that can be triggered from show control events or handled through its internal playback system. Integration depth is strongest when the show relies on OSC and networked synchronization rather than console-style manual cue stacks.
- +Media-first timeline workflow ties looks to playback without separate automation glue
- +OSC-based control supports external triggering and parameter updates
- +Fixture parameter mapping supports repeatable show looks across multiple rigs
- +Performance-oriented real-time playback suits reactive visual shows
- –Console-style cue stack and patch governance workflows need careful project structure
- –Advanced DMX addressing and multi-universe routing often require disciplined setup
- –Deep console features like complex tracking modes may feel less native than in lighting desks
- –Large productions can become harder to manage when visuals and lighting logic grow together
Stage managers and show operators
Trigger authored visual scenes live
Repeatable show operation
Lighting designers and installers
Map media visuals to fixture layout
Deterministic stage previews
Show 2 more scenarios
VJs and live video operators
Blend multiple sources with transitions
Responsive visual compositions
Teams mix layers, masking, keying, and transitions that match stage timing.
Performance collectives
Route synchronized visuals across screens
Consistent multi-screen visuals
Artists create reusable visual patches and drive coordinated output to multiple canvases.
Best for: Fits when shows need visual-driven lighting playback with external OSC triggering and fast look changes.
QLC+
free-tierQLC+ is open-source lighting control software for DMX, MIDI, OSC, and show playback workflows.
Timeline-based cue authoring combines effects and timed steps inside one show project.
QLC+ is built around a show file that combines fixture configuration, a patch list, and a cue stack into one repeatable project. The offline editor lets teams build tracking and fades before any network connection, then switch to live playback for control and updates. Automation is mainly achieved through cue sequencing, timeline steps, and effect generation rather than external scripting or web services.
- +Offline show editing with cue rehearsal before connecting lighting hardware
- +Configurable universe mapping supports multi-output DMX layouts
- +Timeline and effect-driven cues reduce manual busking workload
- +Project-based fixture patching keeps show state consistent across rehearsals
- –No native multi-user control model for shared governance
- –Automation is limited to show cues rather than external orchestration APIs
- –Hardware discovery features are not as centralized as console ecosystems
- –Complex productions can require careful project organization to stay manageable
Volunteer theatre crews
Rehearse cues offline, then play live
Fewer rehearsal delays during changeovers
Event lighting technicians
Patch shared inventory per venue
Consistent results across venues
Show 1 more scenario
Small production teams
Drive multiple DMX outputs from one workstation
Single operator playback workflow
Operators route universes and cue playback from one QLC+ instance to cover larger rigs and distribution setups.
Best for: Fits when a single operator needs offline cue authoring and multi-universe DMX output control.
DMXControl
SMBFree open-source lighting control software developed by a German community.
Fixture-profile based parameter and channel modeling that drives cue playback and effects from a structured fixture definition.
DMXControl is a stage lighting control application that drives DMX universes through console-like features such as cue stacks, submasters, and a patch list. Its standout strength is integration depth with a fixture model that supports per-fixture parameter handling, plus a built-in timeline editor for offline cue creation and rehearsal.
- +Cue stack playback with explicit fade and timing control
- +Timeline editor supports offline rehearsal workflows
- +Fixture profiles model device parameters for repeatable programming
- +Submasters and groups simplify show-level control
- –Onboarding to DMXControl concepts takes more time than mainstream desks
- –Complex patch and universe mapping can slow early setup
- –GUI state management can feel heavy for fast busking sessions
- –Advanced effect timing needs careful testing per fixture profile
Lighting designers and stage teams
Combine patch plan with cue content
Continuity between planning and playback
Small venue operators
Control DMX fixtures from a laptop
PC-based fixture control
Show 2 more scenarios
Production crews for large rigs
Manage multi-universe lighting networks
Structured distributed control
Crews route output across universes with Art-Net or sACN for distributed venues.
Show control integration teams
Trigger lighting changes via OSC or MIDI
Remote cue triggering
Teams connect external controls to trigger cues and adjust lighting during performances.
Best for: Fits when teams need offline cue building plus consistent cue playback for multi-universe shows.
Sunlite Suite
vertical specialistDMX lighting control software with fixture libraries, timelines, scenes, and live playback tools.
Integrated offline editor and stage playback loop that keeps cue timing consistent across rehearsal and live operation.
Sunlite Suite runs a lighting workflow that combines fixture patching, cue creation, and show playback inside a single timeline-driven control environment. It supports DMX output routing through a patch list tied to fixture profiles, which makes it practical for both small rigs and multi-fixture shows.
- +Single timeline authoring workflow for cues, timing, and playback
- +Fixture profile driven patch list keeps addressing consistent
- +Offline authoring supports rehearsals without stage hardware present
- +Effect-oriented workflows speed repeated motion patterns
- –Advanced show structures need more manual cue management
- –Multi-controller synchronization workflows are less guided than peers
Lighting designers
Author cues in a single timeline workflow
One place for authoring
Stage production teams
Prepare offline cues and test timing
Reduced rehearsal surprises
Show 1 more scenario
Small rig operators
Route DMX through a fixture patch list
Predictable output mapping
Operators tie DMX routing to fixture profiles so parameter behavior matches the rig.
Best for: Fits when a small or mid-size crew needs integrated cue authoring and stage playback without complex console workflows.
Isadora
vertical specialistInteractive media software with DMX, Art-Net, MIDI, OSC, video, audio, and sensor integration.
Timeline-authored show logic drives lighting output with media-style scene reuse.
Isadora from troikatronix.com focuses on timeline-driven light control built for creative media workflows. It connects visual programming-style authoring with stage-safe output by mapping media and cue logic to DMX or Art-Net style transport.
- +Timeline-first cues keep light changes aligned with visuals during rehearsal
- +Scene and routing logic supports reusable show components
- +Live playback stays organized through structured cue sequencing
- +Output mapping to common network lighting transports supports mixed environments
- –Console-style busking workflows can feel less direct than dedicated lighting desks
- –Large patch lists demand careful organization to avoid addressing mistakes
- –Extending show logic beyond built-in behaviors requires nontrivial authoring
- –Debugging timing issues takes more effort than cue-list based consoles
Stage production teams
Coordinate lighting cues with clip triggers
Repeatable coordination
Theater and dance teams
Drive visuals from performer and camera inputs
Responsive visual changes
Show 2 more scenarios
Interactive installation creators
Map device input to mapped playback behavior
Reactive visitor-driven visuals
Creators connect sensor or device input to effects, transformations, and display output.
Projection mapping teams
Run mapped scenes with timeline cues
More consistent transitions
Teams build projection states with repeatable timeline cue changes for live events.
Best for: Fits when creative teams need timeline-authored light automation tied to media scenes.
Jands Vista
SMBTimeline-based lighting control software for theatrical and live event use.
OSC-style messaging plus show timing workflow supports external cue synchronization without rewriting the cue stack.
Jands Vista controls stage lighting through cue-based playback with show control style workflows and an offline-centric editor approach. Jands Vista supports fixture patching with profiles, organizes cues into a cue stack, and lets operators build timing with fade and timing controls for consistent show playback.
- +Cue stack workflow keeps show timing predictable across long runs
- +Offline editing supports structured fixture patching and repeatable playback
- +Fixture profiles reduce manual parameter mapping during programming
- +OSC-style messaging supports external synchronization for cues
- –Universe and addressing changes require careful patch alignment
- –Automation and integration depth depends on how external timecode is handled
- –Effect and tracking workflows can feel console-centric during complex edits
- –Advanced multi-output routing needs disciplined configuration
Lighting programmers
Build timed cue stacks for performances
Consistent show playback
Integrators for lighting networks
Run cues over DMX and Art-Net style transports
Networked lighting output
Show 1 more scenario
Media and timecode operators
Sync cue playback with MIDI timecode
Synchronized cue changes
Teams coordinate lighting cues with timecode-driven operation using MIDI timecode and OSC-style messaging.
Best for: Fits when touring teams need cue-based programming with repeatable patch and timecode-driven playback.
Lightjams
API-firstShow control software that combines DMX lighting with MIDI, OSC, audio, sensors, and automation.
Timeline-to-cue stack authoring with granular fade and behavior settings per cue
Lightjams centers on timeline-first authoring that converts edits into a cue stack for playback control.
- +Timeline-based cue creation makes complex shows easier to iterate
- +Fixture profile and patch workflow supports repeatable programming across rigs
- +Cue stack playback keeps show order explicit and debuggable
- +Parameter-level control supports detailed look development per fixture
- –Multi-universe routing requires careful node and address planning
- –Advanced automation needs more setup than console-style direct programming
Lighting programmers
Program timed scenes into a cue sequence
Rehearsable cue sequence
Lighting technicians
Patch fixtures and play channel-based looks
Organized cue playback
Show 2 more scenarios
Interactive experience creators
Trigger lighting behavior from external input
Input-driven lighting
Creators connect sensors or other external triggers to drive lighting responses in installations.
Musicians and live show operators
Trigger lighting via MIDI performance data
Lighting linked to MIDI
Operators map MIDI input to lighting changes and show actions during live sets.
Best for: Fits when production teams want a timeline-driven cue stack with repeatable fixture patching.
Cuelux
SMBDMX lighting control software for creating cues, scenes, timelines, and live playback controls.
Cue stack editing and playback controls organized around fixture parameter changes instead of raw channel editing.
Cuelux, from visualproductions.nl, is a stage light control software centered on a visual workflow for building cue lists and running shows from a lighting desk style interface. It supports fixture-centric setup through configurable fixture profiles and patching so cues target real device parameters instead of raw channels.
- +Cue stack workflow matches desk-style show playback
- +Fixture profiles make parameter editing more repeatable
- +Live-friendly controls support fast scene iteration
- +Visual cue building reduces reliance on channel math
- –Feature depth for console-style automation is limited versus QLC+ class tools
- –Complex multi-universe setups require careful patch and mapping discipline
Lighting operators
Run shows from a desk-style cue interface
Faster live operation
Lighting techs and programmers
Target devices using fixture profiles and patching
Device-accurate cue control
Show 1 more scenario
Stage crews with complex DMX addressing needs
Resolve universe routing and cue parameter behavior
Working playback on stage
Crews translate fixture behavior into usable profiles after addressing and universe setup work.
Best for: Fits when a small show crew needs fast cue building and predictable fixture targeting without deep console programming workflows.
Conclusion
After evaluating 10 stage light control software, Lightkey stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
How to Choose the Right Stage Light Control Software
This buyer's guide covers stage light control software used to author cue stacks, map fixtures, and drive output across single and multi-universe lighting networks. The tools covered include QLC+, Lightkey, Daslight, DMXControl, Jands Vista, Millumin, Lightjams, Isadora, Sunlite Suite, and Cuelux.
The comparison sections focus on how each tool handles cue authoring and playback continuity during rehearsal, plus how timeline workflows connect to patch mapping and external triggers. QLC+ leads for offline cue authoring that combines timed steps and effects inside one show project, while Lightkey emphasizes timeline-style editing linked to patch mapping for repeatable playback.
Stage Light Control Software for cue stacks, fixture patching, and timed show playback
Stage light control software lets operators build cue stacks, define fixture profiles, and apply timed fades so live playback matches offline rehearsal. Tools such as QLC+ and Daslight keep cue stack structure and offline editing in the same workspace, so show timing and cue intent stay consistent when lighting hardware connects.
For multi-system productions, stage light control software also defines how timeline or cue logic integrates with routing and external control signals. Lightkey ties cue stack and timeline editing to patch workflow so channel changes propagate reliably across universes, while Jands Vista uses OSC-style messaging and show timing workflow to support external cue synchronization without rewriting the cue stack.
How to choose based on workflow depth, integration surface, and operating model
The right stage light control software choice depends on whether a production operates from one operator’s offline show project or from external systems that drive lighting playback. The selection also depends on how much the workflow expects operators to manage patch alignment and mapping discipline across universes and controllers.
Choose timeline-first authoring when rehearsal edits are the main production driver
Pick QLC+ or Lightjams when cue creation and iteration depend on timeline steps that translate into a cue stack with repeatable timing. QLC+ focuses on timed steps and effects inside one project, while Lightjams adds granular fade and behavior settings per cue.
Choose cue-stack continuity tools when the same structure must survive offline rehearsal and live playback
Pick Daslight or Sunlite Suite when offline-to-live continuity must remain in one tool with minimal workflow translation. Daslight feeds the same cue stack for offline editing and live playback, while Sunlite Suite keeps cue timing consistent with an integrated stage playback loop.
Choose fixture-model driven tools when channel logic must be governed through structured profiles
Pick DMXControl when fixture-profile based parameter modeling is required to keep cue playback consistent across complex builds. Pick Cuelux when parameter editing centered on fixture profiles reduces direct raw channel targeting during cue authoring.
Choose patch-aligned timeline editing when multi-universe mapping changes are routine
Pick Lightkey or QLC+ when patch mapping and timeline edits must stay synchronized as universes and fixture channel layouts evolve. Lightkey focuses on reliable propagation of channel changes into playback, while QLC+ provides configurable universe mapping for multi-output DMX layouts.
Choose external synchronization messaging when cue triggering comes from outside lighting
Pick Jands Vista when external cue synchronization is driven by OSC-style messaging with show timing that stays predictable. Pick Millumin when visuals drive lighting parameter updates through media-parameter mapping tied to OSC-based control.
Who Stage Light Control Software fits best
These tools fit teams that author cue stacks, rehearse cue timing offline, and then operate live output with predictable playback behavior. The fit changes by team workflow, especially whether the show is authored in one application or driven by external triggers like OSC-based systems.
Small show crews doing cue authoring and stage playback without console-style complexity
Sunlite Suite and Cuelux support integrated offline cue authoring and cue stack playback using fixture-profile driven editing patterns.
Single-operator venues that rehearse offline and then connect hardware for multi-universe DMX output
QLC+ is built for timeline-based cue authoring within one show project plus configurable universe mapping for multi-output DMX layouts.
Touring teams that need external cue synchronization and predictable timing across long runs
Jands Vista supports OSC-style messaging and a cue timing workflow that stays consistent without rewriting the cue stack.
Creative teams integrating visuals with lighting parameters in the same timeline workflow
Millumin ties media-parameter mapping to fixture parameters and supports OSC-based triggering and parameter updates for fast look changes.
Lighting teams building structured fixture logic to keep cue playback consistent
DMXControl uses fixture-profile based channel and parameter modeling that drives cue playback and effects from structured fixture definitions.
Common Stage Light Control Software pitfalls
Most failures come from cue intent breaking during edits or from patch alignment mistakes when universes and fixture addressing change late. Other failures happen when external orchestration is expected from features that only cover internal cue playback.
Changing universe mapping late and assuming cue stack playback will stay aligned without reviewing mapping
QLC+ and Lightkey both hinge on patch and universe alignment staying consistent with offline edits, so multi-output DMX layouts require explicit verification after mapping changes.
Assuming deep external orchestration is native instead of being limited to cue playback
QLC+ automation stays focused on show cues rather than external orchestration APIs, so multi-system control needs a clear integration plan with Jands Vista or Millumin where external triggering is part of the workflow.
Treating fixture definitions as optional and editing raw channel data across large rigs
DMXControl onboarding takes more time because fixture-profile concepts must be set up correctly, and Cuelux reduces raw channel edits by centering parameter targeting on fixture profiles.
Using timeline cues without managing cue fade timing expectations across rehearsal and live playback
DMXControl provides explicit fade and timing control in cue stack playback, while Lightjams includes granular fade and behavior per cue, so fade semantics must match the operation style.
How We Selected and Ranked These Tools
We evaluated QLC+, Lightkey, Daslight, DMXControl, Jands Vista, Millumin, Lightjams, Isadora, Sunlite Suite, and Cuelux using features at 40%, ease at 30%, and value at 30%. Features score emphasized how timeline authoring maps into a cue stack workflow, how offline rehearsal continuity stays aligned with live playback, and how patch mapping and fixture definitions shape cue behavior.
Ease score emphasized how quickly operators can reach usable cue playback with cue rehearsal in the same workspace. QLC+ ranked first because its timeline-based cue authoring combines timed steps and effects inside one show project, and its configurable universe mapping supports multi-output DMX layouts while keeping offline edits usable during rehearsal.
Frequently Asked Questions About Stage Light Control Software
How do QLC+ and DMXControl handle timeline-based cue authoring for rehearsal versus live playback?
Which tools support multi-universe network output using configurable universe mapping?
When should a production choose fixture-profile parameter modeling in DMXControl over raw channel patching workflows?
What breaks if a show relies on OSC-based cue synchronization without confirming support in the chosen software?
How do Lightjams and QLC+ differ in the way they connect timeline scenes to cue stack playback behavior?
Which platform best fits installations that need media-driven lighting rather than console-style cue lists?
How does Lightkey manage cue creation and parameter mapping when patch changes occur late in production?
What security and admin controls are commonly required when multiple operators share the same stage controller workspace?
How do teams migrate existing show data when switching between cue stack systems like Cuelux and Daslight?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
Funding and competing interests
This study was co-funded by several of the vendors assessed in it. No single vendor funded it. Funders could propose the market studied.
They had no role in selecting vendors, setting or weighting criteria, analysing data or drawing conclusions, and they received the same factual-accuracy check as every other vendor assessed.
Market definition, inclusion rules and criteria weights were fixed by an editor before research began and did not change afterwards. Editorial process →
Keep exploring
Comparing two specific tools?
Software Alternatives
See head-to-head software comparisons with feature breakdowns, pricing, and our recommendation for each use case.
Explore software alternatives→In this category
Art & Design alternatives
See side-by-side comparisons of art & design tools and pick the right one for your stack.
Compare art & design tools→