GITNUXSOFTWARE REVIEW
Environment EnergyTop 10 Best Lights Software of 2026
Compare lights software options and where they fit, with clear tradeoffs for choosing tools like Luminar Neo, Lightworks, and QLC+.
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 rankings. Editorial policy
Luminar Neo is the best pick for photo teams that want fast, polished lighting look updates because its AI-assisted sky replacement and built-in subject masking speed up edits without heavy manual work, while QLC+ is the better alternative for operators who need open, cross-platform control thanks to its widget-based virtual console that maps reusable functions to custom layouts.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Luminar Neo
AI-assisted sky replacement and subject masking built into the editing layer system.
Best for: Fits when photo teams need fast AI image finishing for lighting show review and presentation images.
Lightworks
Editor pickOffline editing tied to cue playback logic for rehearsal-ready timing without relying on live-only busking.
Best for: Fits when teams need cue-driven lighting control that connects video production steps to DMX playback.
QLC+
Editor pickThe widget-based Virtual Console maps reusable functions to configurable buttons, sliders, knobs, and custom control layouts.
Best for: Fits when operators need cross-platform control, custom fixtures, and reusable show functions without proprietary console hardware.
Comparison Table
Luminar Neo
creativePhoto editing software with relighting, masking, and AI-assisted enhancement tools.
AI-assisted sky replacement and subject masking built into the editing layer system.
Luminar Neo is a photo editor that focuses on AI-driven enhancement rather than fixture control or cue choreography. Image content is processed through effect presets and masks, including sky and subject separation controls that update non-destructively.
The workflow centers on running offline edits, organizing catalog projects, and exporting finished images for downstream use in presentations or previews. For lighting workflows, Luminar Neo works best as a visual post tool that helps teams prepare images for show review rather than authoring DMX or Art-Net control data.
- +AI sky and subject separation reduces manual masking work
- +Non-destructive layers and adjustable effect sliders support quick iteration
- +Catalog and organized projects help manage large photo sets
- +Batch export workflow fits recurring review and presentation output
- –No lighting-console features like cue stacks, submasters, or timecode triggers
- –No native DMX512, Art-Net, sACN, or RDM patching workflow
- –Automation and API surface are not exposed for show-control integration
- –Pixel mapping, fixture profiling, and moving-light programming are unsupported
High-volume event photography teams
Apply saved looks to many images
More consistent gallery imagery
Portrait photographers and creators
Use face-aware polishing on subjects
Faster consistent retouching
Show 2 more scenarios
Creative marketers and editors
Build editable montages with AI separation
Editable composite visuals
Layered composites with AI subject separation support fast, editable visuals for show reviews.
E-commerce product content teams
Sharpen details with masked control
Sharpened selected areas
Masked sharpening targets portraits, products, and distant details for clearer assets.
Best for: Fits when photo teams need fast AI image finishing for lighting show review and presentation images.
Lightworks
creativeNonlinear video editing software for content creation, broadcast, and post-production workflows.
Offline editing tied to cue playback logic for rehearsal-ready timing without relying on live-only busking.
Lightworks is a lights software package built around video-centric editing and control export workflows rather than a traditional console-only authoring model. Core capabilities focus on cue-based playback control, fixture patching with profile support, and output targeting for network DMX distribution.
Scene and cue creation can be done with offline editing steps, then driven during rehearsal and performance from the same cue logic. For teams that want tight collaboration between visual content creation and lighting cue execution, Lightworks keeps the pipeline inside the editor-to-playback flow.
- +Offline cue editing supports rehearsal workflows with predictable cue timing
- +Fixture patching and profiles reduce ambiguity when programming repeated shows
- +Network DMX output supports multi-universe delivery patterns
- +Video-oriented control authoring helps teams reuse content production skills
- –Workflow depth favors established lighting processes over console-first busking
- –Advanced timing tasks require careful cue stack management to avoid surprises
- –Integration with external show controllers can be limited without extra automation
- –Library and asset management can feel heavy for frequent fixture swaps
Event and studio video editors
Coordinate multicamera edits with cue playback
Selectable angles during rehearsal
Production teams handling heavy media
Edit with proxy files then relink
Conform-ready lighting project
Show 2 more scenarios
Editorial finishing and delivery roles
Trim and finish sequences for render
Technically reviewed delivery sequence
Finishing editors use review tools and render controls to deliver sequences aligned with cue timing.
Effects-focused video production staff
Combine timeline editing with DVE effects
Edited content with integrated effects
Effects creators build enhanced timelines and drive cue execution from the same editing workflow.
Best for: Fits when teams need cue-driven lighting control that connects video production steps to DMX playback.
QLC+
API-firstOpen-source lighting control software for DMX, MIDI, OSC, and live show programming.
The widget-based Virtual Console maps reusable functions to configurable buttons, sliders, knobs, and custom control layouts.
QLC+ runs on Windows, macOS, and Linux, which suits mixed computer fleets and portable show rigs. Its Function system stores scenes, chasers, EFX sequences, RGB matrix patterns, audio triggers, video triggers, and scripts as reusable building blocks. The Virtual Console exposes those functions through buttons, sliders, knobs, and custom layouts.
The tradeoff is configuration depth because larger shows can require manual fixture-definition work, function nesting, and widget mapping before rehearsal. Small venues, community productions, and independent programmers benefit from reusable show files without being tied to proprietary console hardware. QLC+ lacks native multi-user permissions and centralized show governance for larger teams.
- +Open-source codebase supports Windows, macOS, and Linux deployments.
- +Widget-based Virtual Console adapts to buttons, sliders, knobs, and custom layouts.
- +Function system reuses scenes, chasers, effects, and matrix patterns.
- +Custom fixture definitions cover uncommon or newly acquired fixtures.
- –Large shows demand manual function nesting and widget mapping.
- –Native multi-user permissions and centralized show governance are absent.
- –Advanced tracking workflows are less developed than dedicated consoles.
- –Fixture-definition quality depends on community files or operator editing.
Small venue operators
Weekly live shows
Faster show preparation
Touring lighting programmers
Mixed operating systems
Flexible computer choice
Show 1 more scenario
Installers and integrators
Custom fixture deployment
Broader fixture coverage
Fixture definitions and network outputs accommodate equipment absent from the default collection.
Best for: Fits when operators need cross-platform control, custom fixtures, and reusable show functions without proprietary console hardware.
Capture
enterpriseLighting design, visualization, and documentation software for entertainment production.
Shared 2D drafting, 3D visualization, and show documentation within one editable project.
Capture links venue geometry, fixture positions, focus points, and rendered output within one project structure. Designers can compare looks, test focus and color changes, and produce documentation without maintaining separate drafting and visualization files. The workflow suits teams that need previsualization tied to show data rather than a standalone renderer.
- +Integrated drafting, visualization, and documentation share one project
- +Live console output makes preprogramming testable before load-in
- +Large fixture library reduces manual fixture setup
- +CAD imports support detailed venue reconstruction
- –Console-specific programming features remain outside Capture's scope
- –Large venue files can increase rendering and viewport demands
- –Unavailable fixture definitions require manual profile checking
- –Detailed projects require disciplined venue modeling
Touring lighting designers
Validate rigs before venue load-in
Fewer on-site programming revisions
Production design teams
Model complex temporary venues
Clearer preproduction approvals
Show 1 more scenario
Lighting education programs
Teach visualization workflows
More repeatable classroom practice
Students can practice show visualization and fixture placement without occupying a physical venue.
Best for: Fits when production teams need one venue model for drafting, visualization, and console validation.
LightBurn
vertical specialistLayout, editing, and control software for laser cutters and engravers.
Offline vector-to-device workflow with calibration-aware layout preview for deterministic laser runs.
LightBurn is lighting software built around offline layout, visualization, and laser-centric control workflows. It imports vector art, creates a repeatable design-to-output workflow, and manages devices with a fixture and material-focused toolchain.
- +Vector import and offline preview reduce on-device guesswork
- +Device calibration and coordinate workflow stays consistent across re-runs
- +Edit modes support blind and guided changes without losing scene structure
- +Job files preserve repeatable outputs for production batches
- –Lighting console workflows like submasters and cue stacks do not map directly
- –Multi-device setups demand careful device configuration discipline
Personalized product makers
Engrave logos and lettering on boards
Repeatable engraveable board artwork
Photo engraving businesses
Convert bitmap photos into raster jobs
Engraved photos with tuned settings
Show 2 more scenarios
Sign and label producers
Plan signs and plaque engraving batches
Organized editable production layouts
Lay out text, logos, and linework in a single editable project for consistent previews and output.
GRBL laser operators
Create motion output for controllers
Connected design-to-machine output
Generate vector-driven motion output and control compatible laser or CNC equipment from a desktop workflow.
Best for: Fits when laser designers need offline layout, calibration, and repeatable show or batch outputs.
Light-O-Rama
vertical specialistSequencing and control software for animated holiday lighting displays and smart show hardware.
Offline sequence creation tied to cue scheduling for controller-ready show runs.
Light-O-Rama software is built around creating show control data for holiday and decor lighting installs using cue lists and scene style programming. It includes an offline workflow with sequence editing, fixture/channel patching, and playback/export oriented output preparation for multi-controller setups.
- +Cue list based sequencing keeps long shows organized
- +Offline editing supports patching and preview before show playback
- +Channel and fixture mapping workflow supports multi-controller deployments
- +Effect authoring and reuse helps maintain consistent visuals
- –Workflow is tuned for event lighting more than live console style programming
- –Complex multi-universe setups can require careful patch discipline
- –Advanced integration with external lighting consoles is limited
- –Large project navigation can feel slower than console-centric editors
Seasonal display operators
Schedule repeatable holiday music-synced light shows
Repeatable programmed home displays
Church and community organizers
Run coordinated lighting on recurring schedules
Consistent show execution
Show 2 more scenarios
Multi-controller lighting teams
Synchronize outputs across distributed controllers
Synchronized multi-area lighting
Prepare show control data that aligns timing across fixtures and controller areas for one coordinated run.
Pixel display technicians
Program RGB pixel strings and panels
Pixel-accurate programmed effects
Map addressable LED elements to channels and sequence pixel-accurate effects for each configured output.
Best for: Fits when holiday and decor teams need offline cue sequencing for controller playback without live console workflows.
LightAct
vertical specialistMedia server and mapping software for projection, interactive visuals, and multimedia control.
Offline editing with blind changes plus cue fade timing for controlled rehearsal-to-show updates.
LightAct is lighting software built around a fixture-first workflow for visual programming and on-console-ready control outputs. It supports patching with a fixture library, building cue lists and scene presets, and running playback through its show control timeline.
- +Fixture library plus patching workflow reduces time from specs to playback
- +Cue list and scene preset structure supports repeatable show builds
- +Blind editing with cue timing helps keep rehearsal and updates controlled
- +Protocol output support supports multi-universe lighting control deployments
- –Advanced scene and palette behaviors require careful workflow planning
- –Complex productions need disciplined cue naming and library management
- –Live show changes can feel slower than pure busking-focused tools
- –Visualization and offline editing workflows can demand extra setup effort
LED technicians and live event teams
Map pixel artwork to show playback
Consistent pixel content across matrices
Virtual production and VFX teams
Iterate lighting for shot previs scenes
Quicker camera and lighting revisions
Show 2 more scenarios
Projection mapping and production crews
Calibrate facade geometry and timing
Repeatable facade projections
Builds geometry-aware facade mappings with calibrated projector outputs and timed scene playback.
Multimedia show control operators
Synchronize lighting with media cues
Improved cue alignment
Coordinated playback ties lighting changes and projection scenes to a shared show workflow and timing.
Best for: Fits when teams need editable cue stacks and scene presets with real playback control.
Lightjams
vertical specialistInteractive lighting control software for live shows, installations, and LED systems.
OSC and MIDI Show Control input support for driving scenes from external controllers during rehearsals and performances.
Lightjams focuses on software-controlled lighting with a fixture library and a visual workflow for building cues and scenes. It supports common network lighting data paths such as DMX512, Art-Net, and sACN for driving real fixtures from the editor.
- +DMX512, Art-Net, and sACN output cover typical venue network setups
- +Fixture library and patch workflow reduce mismatch between show and hardware
- +Timeline-based cues support repeatable scene transitions and rehearsals
- +OSC and MIDI Show Control inputs support hybrid show-control automation
- –Cue stack control and show operator functions are not as deep as console-grade software
- –Multi-universe scaling can require careful output mapping and testing
- –Complex effect-driven looks may take more time to tune than on cue-focused editors
Event production lighting team
Rehearse cues and validate fixture output
Reviewed lighting cues before show
Musicians and live show operators
Trigger lighting changes from MIDI
MIDI-driven lighting control
Show 2 more scenarios
Interactive installation creators
Drive lighting via external triggers
Lighting responds to input
Connect lighting behavior to external control paths for responsive, non-manual operation.
Stage programmers and directors
Build timed scenes for playback
Consistent scene playback in rehearsals
Program repeatable cue sequences with transitions inside the show timeline.
Best for: Fits when small to mid-size shows need network DMX control, repeatable cues, and external show triggers.
Madrix
vertical specialistLED lighting control software for pixel mapping, effects generation, and large installations.
Effect-to-fixture pixel mapping with cue-ready scene control for dense LED layouts.
Madrix targets stage and venue lighting workflows with real-time control over DMX512 and Art-Net. It includes a scene and cue system for repeatable shows, plus pixel-mapping style effects for high-density LED installations.
- +Strong pixel-mapping style effects for LED and matrix layouts
- +Multi-universe patching supports large installations without splitting workflows
- +Cue stacks and scene presets support repeatable show playback
- +OSC and MIDI Show Control integration fits external show-control systems
- –DMX512 output coverage depends on correct universe planning
- –Large fixture libraries and mappings require careful organization
- –Advanced automation often needs console-like workflow discipline
- –Visualizer and preview fidelity can differ from final controller timing
Holiday lighting designers
Sequence RGB props with beat timing
Repeatable beat-aligned light shows
Laser show programmers
Run pixel-driven beam patterns
Cue-based laser scene playback
Show 2 more scenarios
Live event technicians
Automate cues from external triggers
More consistent show triggering
Technicians use MIDI or external control to start scenes and reduce manual operation during shows.
Venue operators
Control multi-zone fixtures over network
Centralized control of distributed zones
Operators group fixtures and pixel sets by zone and deliver networked DMX and Art-Net output.
Best for: Fits when lighting operators need real-time cues and pixel effects with external show-control hooks.
LightFactory
vertical specialistPC-based DMX lighting control software for live performance and entertainment venues.
Magic Sheet editor for custom touchscreen layouts that combine fixture controls, cues, groups, and playback buttons.
LightFactory gives operators a desktop programmer, live playback controls, and a cue stack within one Windows application. Custom Magic Sheets can expose only the controls needed by volunteers, performers, or venue technicians. Fixture patching and live channel editing remain available without leaving the main control workflow.
- +Magic Sheets create role-specific touchscreen control layouts.
- +Art-Net and sACN outputs support networked lighting systems.
- +Fixture patching and channel editing remain accessible during live operation.
- +Built-in effects and playback faders reduce repeated manual programming.
- –Windows deployment limits native use on macOS and Linux.
- –Large shows require careful screen organization as controls multiply.
- –Advanced remote administration is less developed than enterprise control systems.
- –Visualizer integration is not the main focus of the workflow.
Theatre technicians
Repeated repertory productions
Faster show setup
Worship production teams
Volunteer-friendly live operation
Fewer operator errors
Show 1 more scenario
Mobile production crews
Networked venue control
Flexible venue deployment
Art-Net and sACN outputs connect LightFactory to existing Ethernet lighting infrastructure.
Best for: Fits when operators need customizable touchscreen layouts for theatrical shows, worship services, and repeatable live events.
Conclusion
After evaluating 10 lights software, Luminar Neo 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 Lights Software
Lights software in this guide spans show programming and venue validation tools like Capture, touchscreen control layout editors like LightFactory, and cross-platform virtual console builds like QLC+. The list also covers non-console lighting workflows like LightBurn, video-production cue playback tools like Lightworks, and external-trigger show control inputs like Lightjams and OSC-driven setups.
The remaining entries include LightAct for editable cue stacks with blind updates, Light-O-Rama for controller-ready offline sequencing, and Madrix for effect-to-fixture pixel mapping with cue-ready scene control. Each section focuses on integration depth, automation and API surface where present, and control and governance behaviors that affect multi-operator operation.
Lighting console and show-control software for patching, cue stacks, and output control
Lights software coordinates fixture patching, cue sequencing, and playback controls that drive lighting outputs over networks and device interfaces. Capture is built around a single editable project that combines 2D drafting, 3D visualization, and show documentation with live console output for preprogramming validation before load-in.
LightFactory centers on a Magic Sheet editor that assembles role-specific touchscreen controls from fixtures, cues, groups, and playback buttons, with Art-Net and sACN outputs for networked lighting systems. QLC+ complements this model with a widget-based Virtual Console that maps reusable show functions onto configurable controls across Windows, macOS, and Linux deployments.
Lights Software capabilities that determine control, validation, and operator governance
Lights software succeeds when it keeps fixture patching, cue execution, and output behavior consistent across rehearsal, load-in, and live operation. Capture prioritizes a single editable project that combines drafting, 3D visualization, and show documentation so teams can validate console intent before hardware commissioning.
One-project venue modeling plus live console validation
Capture links shared 2D drafting, 3D visualization, and show documentation inside one editable project while showing live console output for preprogramming testability before load-in.
Touchscreen control layout authoring for repeatable operator screens
LightFactory uses the Magic Sheet editor to combine fixture controls, cues, groups, and playback buttons into custom touchscreen layouts that map to repeatable live workflows.
Widget-based Virtual Console for custom controls across OS platforms
QLC+ implements a Virtual Console that maps reusable functions to configurable buttons, sliders, knobs, and custom layouts, with support for Windows, macOS, and Linux deployments.
Offline-first sequencing with deterministic re-runs
Light-O-Rama and LightBurn both support offline workflow patterns where show output can be prepared before playback, with Light-O-Rama focused on controller-ready cue scheduling and LightBurn focused on calibration-aware vector previews for device runs.
External show triggers and cue driving through standard input protocols
Lightjams supports OSC and MIDI Show Control input so external systems can drive scenes, while still providing DMX512, Art-Net, and sACN output and fixture library plus patch workflows.
Editable cue stack workflows with blind change updates
LightAct provides offline editing with blind changes and cue fade timing to stage rehearsal-to-show updates while maintaining a cue list and scene preset structure for repeatable builds.
Choose based on your workflow shape for patching, cue editing, and operator control
Start by identifying whether the primary work happens in a venue model, on an operator touchscreen, or in an offline cue timeline. Capture fits teams that need shared venue documentation and 3D validation tied to live console output, while LightFactory and QLC+ fit teams that need custom operator control surfaces.
Select a tool by where venue truth is maintained
If venue modeling and fixture documentation must stay in one editable project, Capture keeps 2D drafting, 3D visualization, and show documentation tied together so preprogramming validation can happen before load-in.
Pick a control-surface authoring model that matches operators
If operators need touchscreen layouts built from fixtures, cues, groups, and playback buttons, LightFactory’s Magic Sheet editor creates role-specific screens. If operators need cross-platform custom control widgets without proprietary console hardware, QLC+ uses a widget-based Virtual Console.
Decide whether offline cue editing or external-trigger driving dominates
If rehearsals rely on cue timing logic prepared offline, Lightworks and LightAct support rehearsal-ready playback behavior with cue timing tied to editing workflows. If external controllers must trigger scenes over the network, Lightjams integrates OSC and MIDI Show Control input with DMX512, Art-Net, and sACN output.
Match multi-device requirements to the tool’s deployment assumptions
If your workflow expects deterministic repeatable runs in an offline editor, LightBurn’s calibration-aware vector-to-device pipeline keeps layout previews consistent across re-runs. If your deployment expects controller-ready offline sequences, Light-O-Rama organizes long shows through cue list based scheduling.
Validate pixel mapping depth against your installation density
If dense LED work needs effect-to-fixture pixel mapping with cue-ready scene control, Madrix’s pixel-mapping style effects target LED and matrix layouts while supporting multi-universe patching.
Who benefits from these Lights Software tools
Capture fits production teams that need one venue model that covers drafting, visualization, and show documentation while still tying to live console output for validation. LightFactory fits lighting operators who must ship repeatable role-based touchscreen control layouts for recurring events.
Venue production teams and show designers who need shared venue documentation plus console validation
Capture’s shared 2D drafting, 3D visualization, and show documentation inside one editable project supports live console output testing before load-in.
Operators running repeatable live events with role-based touchscreen controls
LightFactory’s Magic Sheets build touchscreen layouts that combine fixture controls, cues, groups, and playback buttons into operator-specific screens.
Multi-OS teams that want custom control surfaces without proprietary console hardware
QLC+ uses a widget-based Virtual Console that maps reusable functions to configurable buttons, sliders, knobs, and layouts on Windows, macOS, and Linux.
Installations and rehearsals driven by external show controllers
Lightjams supports OSC and MIDI Show Control input and then outputs DMX512, Art-Net, and sACN using a fixture library and patch workflow.
LED and matrix installations that require effect-to-fixture pixel mapping
Madrix focuses on pixel-mapping style effects for LED and matrix layouts and supports multi-universe patching to handle larger deployments.
Common buying and implementation pitfalls
Many teams buy based on output formats and later discover the tooling mismatch in cue editing depth or control surface workflow. Other teams pick an offline editor and then hit a gap when the live console feature set they need does not exist in that environment.
Assuming console-grade programming features exist in a venue validation editor.
Capture includes integrated drafting and visualization with live console output for preprogramming testability, but console-specific programming features sit outside Capture’s scope.
Underestimating touchscreen layout complexity growth across large shows.
LightFactory’s Magic Sheets support role-specific screens, but large shows require careful screen organization as controls multiply.
Choosing a cross-platform Virtual Console without planning function mapping for large cue systems.
QLC+ supports widget-based control layouts, but large shows demand manual function nesting and widget mapping to keep controls manageable.
Buying an offline laser or media workflow and expecting lighting console cue stack behavior.
LightBurn focuses on offline vector-to-device runs with calibration-aware layout preview, and lighting console workflows like submasters and cue stacks do not map directly.
Assuming external-trigger control tools provide the same cue stack depth as console-grade software.
Lightjams supports OSC and MIDI Show Control input for repeatable cues, but cue stack control and show operator functions are not as deep as console-grade software.
How We Selected and Ranked These Tools
We evaluated each tool on feature depth, operational fit, and the friction created by its editing and deployment model. Features account for 40% of the ranking because these tools vary in cue list structure, Virtual Console control mapping, and offline versus live behavior.
Ease and value each account for 30% because large show files, multi-screen organization, and widget mapping workload can dominate real operator time. Capture ranked highest because it combines shared drafting, 3D visualization, and show documentation in one editable project while also exposing live console output for validation before load-in.
Frequently Asked Questions About Lights Software
How do Capture and LightAct handle venue geometry and offline edits together?
Which tools support network DMX output with Art-Net or sACN, and how does that affect rehearsal workflows?
What integrations and control protocols matter when external devices trigger lighting cues?
How does QLC+ structure its virtual console compared with Lightjams and LightAct?
What tradeoff appears when LightBurn targets offline vector layout instead of show-style authoring?
When is Capture the right choice versus LightFactory for multi-operator preparation?
How do Lightworks and Lightjams differ in where cue timing lives during authoring and playback?
What breaks if a project depends on blind editing and cue fade timing as core features?
How do Madrix pixel-mapping workflows compare with Capture and LightFactory for dense LED setups?
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
Environment Energy alternatives
See side-by-side comparisons of environment energy tools and pick the right one for your stack.
Compare environment energy tools→