GITNUXSOFTWARE REVIEW
Art DesignTop 10 Best Light Designer Software of 2026
Compare light designer software tools and key tradeoffs for lighting design work, including DIALux evo, AGi32, and Lightkey.
How we ranked these tools
Vendors set the topic, but our editors set the inclusion criteria and the evaluation framework before research starts.
Search agents gather the source set and the review record, including transcriptions of 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
DIALux evo is the best pick for lighting teams that need calculation-led design documentation through early layout changes because its results refresh from edits in a tight workflow, while Lightkey suits smaller teams that want cue-stack sequencing tied to previsualization previews for faster iteration.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
DIALux evo
Calculation-driven lighting results that refresh from layout changes during early design review cycles.
Best for: Fits when lighting teams need calculation-driven design documentation more than show programming automation.
AGi32
Editor pickFixture patch list drives 3D layout validation so placement edits update documentation-oriented outputs.
Best for: Fits when drafting-focused light plots need 3D checks and documentation before show-control programming.
Lightkey
Editor pickBuilt-in cue stack sequencing tied to previsualization previews for fast iteration on stage coverage.
Best for: Fits when light design teams need cue-stack programming with visualization checks before desk programming handoff.
Comparison Table
DIALux evo
vertical specialistLighting design software for indoor, outdoor, road, and daylight planning.
Calculation-driven lighting results that refresh from layout changes during early design review cycles.
DIALux evo is a light-designing application focused on lighting layout, calculation, and presentation rather than programming-driven show control. Its strengths center on importing fixture and geometry data, assigning photometric intent per luminaire, and producing calculation-backed visual outputs for design review.
The workflow keeps drafting and documentation close to each other by tying layout changes to re-rendered results. For projects that also need show automation, its value depends on exporting assets to visualization or cueing tools rather than driving a full cue stack.
- +Tight loop between layout edits and rendered lighting outputs
- +Practical fixture library usage with photometric calculations
- +Good support for lighting documentation workflows and handoff graphics
- +Straightforward scene organization for architectural review sets
- –Limited support for timeline sequencing and cue stack authoring
- –Light programming workflows require external show-control tools
- –Integration depth with authoring tools is narrower than show-focused suites
- –Automation and API surface are not as transparent as developer-first tools
Architectural design teams
Compare daylight and electric lighting effects
Side-by-side lighting comparison output
Lighting designers
Create interior layouts with calculated results
Calculated interior lighting layout
Show 2 more scenarios
Landscape lighting designers
Plan outdoor zones with illuminance checks
Zone-based outdoor photometric results
Organize outdoor areas into zones, then calculate fixture coverage and illuminance for photometric design review.
Building services teams
Document emergency lighting in handover
Emergency lighting documentation pack
Include emergency lighting layouts within the project documentation workflow to support planning and handover materials.
Best for: Fits when lighting teams need calculation-driven design documentation more than show programming automation.
AGi32
vertical specialistPhotometric calculation and lighting analysis software for interiors, exteriors, roads, and sports venues.
Fixture patch list drives 3D layout validation so placement edits update documentation-oriented outputs.
AGi32 is lighting design software used to plan, visualize, and document lighting systems for architectural and theatrical projects. Its core workflow centers on building a fixture inventory and patch list, then linking that inventory to 3D visualization for layout checks and documentation outputs.
AGi32 supports common lighting file import and export paths so projects can move between drafting, lighting scheduling, and other design tools without rebuilding the entire rig. Timeline sequencing and final cue programming are handled through its lighting-focused authoring and export workflow rather than general BIM-centric automation.
- +3D visualization workflow built around fixture patching for fast layout validation
- +Documentation outputs align with lighting rig inventories and placement records
- +Integration-friendly import and export pathways for cross-tool lighting drafting
- +Preview and plot-oriented outputs fit typical light plot review cycles
- –Cue timeline authoring depth lags specialized show-control tools
- –Higher-level automation needs disciplined project setup to avoid patch mismatches
- –Automation and API extensibility are not positioned for scripted provisioning workflows
- –Advanced moving-light programming features depend on export and external tooling
Architectural lighting designers
Validate interior luminaire placement and levels
Calculated interior lighting layout
Stage and studio designers
Previsualize fixture optics in scenes
Calculation-informed scene planning
Show 2 more scenarios
Landscape lighting planners
Plan zone layouts with photometrics
Zone-based calculated lighting plan
Organize fixtures by landscape zones and map results to site plan positioning.
Roadway lighting engineers
Assess exterior and roadway light levels
Calculated roadway lighting levels
Run point-by-point calculations and generate visual maps for roadway and outdoor design review.
Best for: Fits when drafting-focused light plots need 3D checks and documentation before show-control programming.
Lightkey
SMBLightkey controls DMX lighting from macOS with fixture management, effects, cues, and MIDI integration.
Built-in cue stack sequencing tied to previsualization previews for fast iteration on stage coverage.
Lightkey targets light designers with an editor workflow that combines patching, cue sequencing, and playback planning.
The product’s design loop centers on previsualization checks so cue changes can be validated without leaving the drafting environment.
Cue stack handling supports rehearsals by keeping sequence edits organized for repeat runs and late-stage refinements.
- +Cue stack programming that fits drafting, rehearsal, and iteration loops
- +Fixture library and patch workflows that reduce friction when expanding scenes
- +Previsualization focus for validating coverage before desk handoff
- +Export and output planning support for moving from editor to performance
- –Live busking workflow needs more discipline than cue-timeline desks
- –Advanced customization depends on understanding the tool’s scene and channel model
- –Complex fixture behaviors can require extra setup time to reproduce faithfully
- –Large-show handling may feel slower than Revit-linked drafting pipelines
Lighting designers and production managers
Package show files and visual plots
Clearer planning to production handoff
Musical fountain show operators
Align light and water patterns to timeline
Consistent repeatable choreography
Show 2 more scenarios
Theater and live-event lighting designers
Build and inspect cues in virtual stage
Fewer changes during technical setup
Validates coverage and movement in a virtual environment before physical setup.
Live operators and venue technicians
Trigger scenes and effects between show segments
Faster response to conditions
Calls cues on demand to adjust looks during timed performances.
Best for: Fits when light design teams need cue-stack programming with visualization checks before desk programming handoff.
Capture
vertical specialistLighting visualization and show design software for entertainment, concert, and event production.
Tight coupling between capture assets and project outputs reduces drift between patching decisions and published documentation.
Capture positions itself as a light design and documentation workflow tool centered on repeatable projects, fixture data, and shot-ready plots. The standout capability is handling designer-friendly capture assets and turning them into patch lists and production-ready documentation without forcing a separate pipeline.
- +Project-first organization keeps patch, cues, and outputs linked together
- +Cue and timeline editing supports practical drafting and revision loops
- +Fixture library use reduces retyping common manufacturer and model data
- +Visualization rendering helps verify sightlines and coverage before plotting
- –Advanced moving light programming workflows need careful manual cue structuring
- –Integration depth is lighter than dedicated visualization suites and console ecosystems
- –RDM-style workflows are not clearly designed around in-field discovery
- –Export formats can feel documentation-led rather than console-ready for every target
Lighting designers
Maintain identities across design revisions
Reused paperwork with less reformatting
Production managers
Generate handoff-ready plot documentation
Clear handoff documents for teams
Show 2 more scenarios
Architectural lighting teams
Iterate layouts in 2D planning
Review-ready lighting layout
Capture supports a 2D workflow to refine fixture placement, mounting details, and zones.
Set and previsualization teams
Block scenes with camera viewpoints
Camera-aware draft scenes
Capture includes camera-aware rendering outputs for blocking stage sets or virtual environments.
Best for: Fits when lighting designers need drafting, patch documentation, and review renders in one repeatable project flow.
LightStanza
SMBCloud-based daylighting and electric lighting simulation software for architectural projects.
Scene and cue editing keeps fixture selections and parameter values consistent while adjusting timeline sequencing.
LightStanza fits designers who draft a patch list, assign fixture capabilities, and then build a cue stack that can be edited without breaking show structure. The workflow stays close to show language, using scenes and cues that map to the same fixture selection and parameter logic used during playback. Visualization rendering supports quicker iteration loops when refining timing and look. Integration depth is strongest inside the authoring environment because show data stays consistent across editing and export steps.
- +Cue stack workflow keeps edits localized to scenes and timing
- +Visualization rendering ties look refinement to the same patch logic
- +Fixture parameter handling supports practical moving-light programming
- +Show organization scales better than flat channel spreadsheets
- –Advanced parameter automation can require more manual cue structuring
- –Limited external API surface for multi-system provisioning workflows
- –Large multi-author governance controls are not the primary focus
- –Complex bus or topology modeling needs careful authoring discipline
Lighting designers
Draft a cue stack for rehearsals
Faster rehearsal iterations
Previsualization teams
Validate looks before controller handoff
Fewer late-stage look changes
Show 2 more scenarios
Small show production crews
Maintain consistent scenes across updates
Lower rework per cue
Edit scene content and sequencing while keeping fixture parameter intent intact across revisions.
Touring programmers
Reuse a show structure across versions
Quicker version adaptation
Keep a stable cue timeline and adjust fixture mapping and parameters for new rigs.
Best for: Fits when lighting designers need cue-timeline drafting with integrated look iteration and repeatable show structure.
LightCalc
SMBOnline lighting calculation software for interior and exterior lighting projects.
GDTF driven fixture definitions that stay connected from patch list drafting through visualization rendering outputs.
LightCalc organizes lighting data around fixtures and placement, then carries that structure into renderable outputs and exportable drafting artifacts. Fixture definitions can be sourced from GDTF files and paired with photometric references for more accurate intensity in previews. The workflow emphasis stays on previsualization quality rather than deep timeline composition, so cue sequencing is treated as an export step instead of a full authoring environment.
- +Patch list creation stays tied to placement and fixture definitions
- +GDTF fixture import supports consistent channel mapping across scenes
- +IES and photometric references improve preview intensity behavior
- +Export formats support downstream plot and rehearsal workflows
- –Timeline cue stack authoring is limited versus dedicated sequencers
- –Advanced moving light effect logic needs external programming tools
- –Complex universe mapping workflows can require extra manual structuring
- –Render settings tuning takes iterative cycles for consistent results
Light design teams
Draft patch from venue plot
Fewer patch mismatches
Previsualization specialists
Generate photometric preview scenes
Earlier creative signoff
Show 2 more scenarios
Production coordinators
Export plot artifacts for programming
Faster desk preparation
Export scene and patch outputs to support downstream desk setup and rehearsal checks.
Busking operators
Rehearse looks from prepared scenes
More consistent rehearsals
Use rendered scenes as reference targets during cue building and busking rehearsals.
Best for: Fits when lighting teams need fast patch and photometric previews for client reviews and rehearsals.
Sunlite Suite
SMBSunlite Suite offers DMX programming, fixture control, effects, timelines, and show playback.
Integrated cue and scene authoring tightly paired with visualization preview for rapid iteration before output.
Sunlite Suite provides a lighting design and control workflow that connects offline programming to live show operation, using a patch list, cue management, and fixture effects in one editor. The suite supports visualization rendering for previsualization work and can drive outputs through common lighting network protocols used in installations.
- +Cue stack workflow supports structured show sequencing and timing
- +Offline visualization rendering helps validate scenes before live operation
- +Fixture effects and parameter fading cover common moving light needs
- +Patch list centric setup reduces friction between design and run
- –Light design import paths from drafting tools can require manual mapping
- –Advanced show automation depends on knowing the suite’s specific cue model
- –Large fixture universes can slow editing when scenes are heavily layered
Concert lighting programmers
Program cues and run live shows
Fewer show programming errors
Rental house previs teams
Render visualization for client approvals
Faster approval cycles
Show 2 more scenarios
Touring production crews
Transfer projects between venues
Reduced reprogramming time
Export and transfer show data into venue workflows for consistent runtime behavior.
Theme park and architectural teams
Control installed fixtures via networks
Reliable automated light sequences
Drive lighting network protocols for synchronized scenes and effect playback in installations.
Best for: Fits when a lighting team needs offline-to-live continuity for cue-driven shows and fixture effects.
AGi32
enterpriseProfessional lighting design and calculation software for interior, exterior, roadway, and daylighting projects.
AGi32 ties fixture definitions and patch lists into 3D visualization for quick spatial QA on real device selections.
AGi32 centers on fixture and channel planning using fixture definitions and patch lists, then carries those selections into visualization for spatial checks. The 3D visualization workflow targets lighting designers who need repeatable scene renders and layout verification alongside drafting artifacts. It also fits teams that want cue-centric review without requiring a full show control stack inside the design step.
- +Fixture library and patch list workflow reduces device mismatch risk
- +3D scene visualization supports spatial review before programming
- +Drafting outputs stay usable for handoff into programming tools
- +Repeatable renders help QA across design iterations
- –Cue stack and timeline sequencing depth is limited versus show control suites
- –Round-trip from BIM tools can require manual re-alignment work
- –Advanced show automation needs external control software
Event lighting designers
Draft a device plot and review renders
Fewer layout corrections later
Theater technical directors
Prepare handoff documents for programmers
Cleaner programming onboarding
Show 2 more scenarios
Stage visualizers
Previsualize lighting looks for stakeholders
Faster design signoff
Produce scene renders to confirm composition and device placement.
CAD and drafting teams
Maintain reusable fixture and scene assets
Reduced rework across seasons
Reuse fixture definitions across revisions and keep documentation consistent.
Best for: Fits when drafting-focused lighting teams need device planning and visualization review before show programming handoff.
Visual Lighting
enterpriseInterior and exterior lighting calculation software with rendering and energy analysis features.
A connected Acuity fixture content workflow that keeps patch list setup aligned with scene planning and project exports.
Visual Lighting from Acuity Brands supports light-design workflows that center on fixture libraries, patch lists, and visual scene planning for architectural and stage projects. It fits drafting teams that need cue stack style sequencing, timeline-based edits, and consistent exports for documentation and build handoff.
- +Fixture and luminaire configuration stays connected to project patching
- +Timeline-style cue editing supports iterative drafting and revisions
- +Export-oriented workflow fits documentation and handoff needs
- +Catalog content reduces re-entry of common fixture attributes
- –Advanced moving-light programming support is limited versus DMX-first tools
- –External control ecosystems rely on manual mapping and format translation
- –Extensibility is constrained compared with tools offering broad scripting
- –Governance controls for multi-user projects are less granular than enterprise suites
Architectural lighting designers
Review renderable fixture scenes
Faster design revision reviews
Project documentation teams
Generate schedules and handoff exports
Consistent schedule and export package
Show 2 more scenarios
Proposals and contractors
Compare layout options for proposals
Better proposal technical support
Evaluate alternative layouts with calculation outputs to support proposal recommendations and documentation.
Exterior lighting designers
Plan outdoor fixtures with calculations
Outdoor plan with calculation outputs
Arrange outdoor fixtures and review photometric performance using calculation outputs for design decisions.
Best for: Fits when teams draft architectural lighting schemes with Acuity fixture content and need cue edits plus exportable handoff.
FreeStyler DMX
SMBFreeStyler DMX is free Windows software for controlling fixtures through DMX, Art-Net, and compatible interfaces.
Live-oriented cue stack playback connected tightly to DMX universe patching and visualization checks.
FreeStyler DMX is a light designer software built around DMX512 control and practical scene programming for live use. It focuses on fixture patching, cue stacks, and timeline sequencing to drive playback while supporting common networking transport options such as Art-Net and sACN.
- +Fast cue stack and timeline sequencing for repeatable stage playback
- +Fixture patching workflow supports practical universe mapping for touring setups
- +Visualization checks help catch patch and addressing errors before rehearsals
- +Built-in live control patterns support busking style operation
- –Effect and parameter logic can feel limited for deep custom automation
- –External visualization and media integration relies on specific supported formats
- –RDM workflows are narrower than dedicated console ecosystems
- –Scaling large shows needs careful patch discipline across universes
Stage lighting designers
Offline cue building for rehearsals
Fewer venue changes
Event lighting programmers
Mapped LED and moving-light scenes
Consistent visual looks
Show 2 more scenarios
Lighting programmers
Visualize fixture motion and timing
Pre-show look verification
Inspect movements, color, levels, and transitions in the visualizer before connecting hardware.
Small venue lighting teams
Reuse house scenes and patches
Reusable programming workflow
Save fixture patches and show files for repeated events and installations.
Best for: Fits when lighting designers need dependable live programming and pre-run visualization without a console-style toolchain.
Conclusion
After evaluating 10 light designer software, DIALux evo 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 Light Designer Software
Light designer software covers the workflow from fixture patch list drafting through cue stack and timeline sequencing, with visualization rendering used for spatial and look validation. This guide covers AGi32, LightStanza, LightCalc, DIALux evo, AGi32 lightinganalysts.com, Visual Lighting, Capture, Lightkey, Sunlite Suite, and FreeStyler DMX.
Across these tools, selection and timing edits can either stay localized to scenes and cue structures or require more external show-control work. The category differences show up most in how fixture definitions connect to patch documentation, how visualization outputs stay aligned to edits, and how much automation depth exists for show programming and effects.
Light Designer Software for drafting, patching, and cue-timeline show planning
Light designer software is used to draft a lighting rig using a fixture library and a patch list, then iterate scenes and cue timing with visualization rendering for review-ready outputs. AGi32 is built around tying fixture definitions and patch lists into 3D visualization for spatial QA before show handoff.
The same drafting-to-review loop appears in LightCalc through GDTF driven fixture definitions that stay connected from patch list drafting through visualization rendering outputs. Other tools like LightStanza focus on keeping fixture selections and parameter values consistent while editing scenes and cue timing within a single cue-timeline workflow. The practical result is less drift between placement records, cue timing edits, and the rendered previews used during rehearsal and client review.
Integration, cue control, and patch-aligned visualization
Light designer software must keep fixture definitions, patch lists, and rendered previews synchronized so spatial QA and client review do not diverge from show programming decisions. The strongest tools tie edits to the same patch logic across visualization and cue workflow so later timing changes do not invalidate rig documentation.
Patch list to 3D scene QA alignment
AGi32 links fixture definitions and patch lists into 3D visualization for spatial QA on real device selections. AGi32 lightinganalysts.com also drives 3D layout validation from the fixture patch list, which keeps documentation outputs aligned with placement records.
Cue stack and timeline sequencing workflow cohesion
LightStanza keeps scene and cue editing consistent while adjusting timeline sequencing, so cue edits stay tied to the same fixture selections and parameter values. Lightkey focuses on cue stack sequencing tied to previsualization previews for fast iteration before desk programming handoff.
GDTF-driven fixture definitions that persist into previews
LightCalc uses GDTF fixture definitions that stay connected from patch list drafting through visualization rendering outputs. Capture also uses a project-first organization that keeps patch, cues, and review renders linked inside one repeatable project flow.
BIM to light plot round-trip tolerance
AGi32 excels at tying patch documentation to visualization for device selection QA, but round-trip from BIM tools can require manual re-alignment work. Revit-based workflows can therefore need extra cleanup when geometry and device placement do not map cleanly back into the patch list.
Moving light programming depth inside the editor
LightStanza supports localized cue edits across scenes and timing, but advanced parameter automation can require more manual cue structuring. FreeStyler DMX delivers fast cue stack playback connected tightly to DMX universe patching, but effect and parameter logic can feel limited for deep custom automation.
Choose by patch-aligned visualization, then by cue control philosophy
The first fork is whether the project workflow should center on patch documentation and visualization QA, or on integrated cue-timeline drafting with in-editor look iteration. Tools like AGi32 and LightCalc prioritize keeping fixture definitions and patch lists tied to preview outputs, which reduces mismatch risk during client and rehearsal review.
Center the workflow on patch-to-visual QA if drafting-to-review is the main deliverable
If rig documentation must match what reviewers see in 3D, prioritize AGi32 or AGi32 lightinganalysts.com because fixture patching drives 3D layout validation and documentation-oriented outputs. This choice supports quick spatial QA before show programming handoff.
Pick integrated scene and cue editing when cue structure is already the project backbone
If the work style requires cue edits to stay consistent with fixture selections and parameter values, choose LightStanza because scene and cue editing remains tied to timeline sequencing. If rehearsal iteration must happen with previsualization tied directly to cue stack previews, Lightkey fits cue-stack programming loops with visualization checks.
Choose GDTF persistence when fixture definitions must stay consistent across scenes and previews
If consistent channel mapping across the patch and preview pipeline is a hard requirement, choose LightCalc because GDTF fixture import stays connected through visualization rendering outputs. This reduces rework when projects reuse photometric and channel definitions.
Separate design calculation and show control when documentation cycles matter more than automation depth
If the priority is calculation-driven lighting outputs refreshed from layout changes, choose DIALux evo because it emphasizes calculation loops over timeline sequencing and cue stack authoring. Expect moving light programming workflows to require external show-control tools.
Plan for manual cue structuring when advanced parameter automation must remain human-authored
If advanced parameter animation must be authored with tight control, validate how much automation exists inside the cue timeline and whether deeper effects need manual cue structuring. LightStanza can require more manual cue structuring for advanced parameter automation, and Capture similarly needs careful manual cue structuring for advanced moving light workflows.
Use a DMX-first tool only when universe patching and live playback are the driver
If touring playback depends on dependable cue stack and universe mapping, use FreeStyler DMX because it connects cue stack playback tightly to DMX universe patching and visualization checks. Confirm effect and parameter logic needs because the tool can feel limited for deep custom automation.
Who benefits from patch-anchored visualization and cue-centric drafting
Light designer software fits different teams based on where draft changes originate and where approvals happen. Teams that draft the rig and verify spatial coverage benefit most from tools that bind patch documentation to 3D visualization previews.
Drafting-focused lighting teams doing rig planning and spatial QA
AGi32 is suited to device planning with 3D visualization review tied to fixture definitions and patch lists, which supports fewer placement mismatches before show handoff.
Cue-timeline drafters who iterate looks inside the same project structure
LightStanza fits teams that edit scenes and cue timing together so fixture selections and parameter values remain consistent while timeline sequencing changes.
Client-review workflows that demand photometric previews tied to fixture definitions
LightCalc supports fast patch and photometric previews because GDTF-driven fixture definitions remain connected from patch list drafting through visualization rendering outputs.
Architectural lighting teams using a vendor fixture content pipeline
Visual Lighting fits teams drafting architectural lighting schemes with Acuity fixture content where fixture and luminaire configuration stays connected to project patching and timeline-style cue edits.
Touring and rehearsal teams that prioritize live-oriented playback
FreeStyler DMX fits live-oriented cue stack playback where universe patching is the workflow anchor and visualization checks happen before run.
Common failure modes during light plot and cue build
Most problems come from drift between placement records, patch definitions, and the visuals used for client or rehearsal approval. Many issues also come from assuming the cue stack editor can replace a dedicated show-control sequencer for complex moving light programming.
Using a 2D or BIM layout edit without validating patch-aligned 3D visualization
AGi32 supports quick spatial QA by tying patch lists into 3D visualization, but BIM round-trips can require manual re-alignment work. Use the 3D scene tied to the current patch list as the approval checkpoint.
Building complex moving light effects inside a tool with limited internal automation depth
LightCalc and DIALux evo both limit timeline cue stack authoring compared with show control suites, which pushes moving light effect logic to external programming tools. Plan the handoff when effect engines exceed what the editor’s cue timeline authoring can cover.
Letting cue timeline edits outgrow the editor’s scene and cue editing model
LightStanza keeps edits localized to scenes and timing, but advanced parameter automation can require more manual cue structuring. Capture similarly supports practical drafting and revision loops, but advanced moving light programming workflows need careful manual cue structuring.
Assuming live playback behavior matches a console workflow without checking effect and parameter logic
FreeStyler DMX focuses on live-oriented cue stack playback connected tightly to DMX universe patching. Effect and parameter logic can feel limited for deep custom automation, so validate the specific effect set used on stage.
How We Selected and Ranked These Tools
We evaluated patch-to-visual QA alignment, cue stack and timeline sequencing depth, and the friction from fixture library to patch list to visualization rendering workflows. Features accounted for 40% of scoring, which favored AGi32 for tying fixture definitions and patch lists into 3D visualization for quick spatial QA on real device selections.
Ease and value each accounted for 30%, which favored tools where scene and cue editing stays consistent with the same patch logic, like LightStanza and LightCalc. AGi32 ranked highest overall because its fixture patching workflow reduces device mismatch risk and supports spatial review before show handoff, even when cue timeline sequencing depth is limited versus show control suites.
Frequently Asked Questions About Light Designer Software
How do cue stack workflows differ between Lightkey, LightStanza, and FreeStyler DMX?
Which tool is better for round-trip review between a light plot and 3D visualization: AGi32 or LightCalc?
When drafting a patch list from a plot, where does LightCalc fit, and what breaks if the project needs CAD-like spatial QA?
Which application handles moving light authoring more directly: Sunlite Suite or DIALux evo?
How do fixture libraries and photometric data workflows differ between LightCalc and Capture?
Which tool provides deeper integration with an existing fixture content ecosystem: Visual Lighting or the rest of the list?
What security and admin controls should teams verify when multiple designers share a project in Lightkey or AGi32?
How does data migration typically work for patch list and fixture inventory continuity across tools like AGi32 and Visual Lighting?
What tradeoff appears when choosing Capture or AGi32 for designing with repeatable project assets versus CAD-like plan QA?
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→