GITNUXSOFTWARE ADVICE
Art DesignTop 10 Best Lighting Designer Software of 2026
Top 10 lighting designer software ranked for lighting design work, with notes on AutoCAD, Capture, and LightConverse and tools like DIALux evo.
How we ranked these tools
Core product claims cross-referenced against official documentation, changelogs, and independent technical reviews.
Analyzed video reviews and hundreds of written evaluations to capture real-world user experiences with each tool.
AI persona simulations modeled how different user types would experience each tool across common use cases and workflows.
Final rankings reviewed and approved by our editorial team with authority to override AI-generated scores based on domain expertise.
Score: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
DIALux evo is the best fit when you need repeatable indoor, outdoor, and daylight calculations with paperwork export for room and façade projects, whereas Blender is a strong alternative if your priority is visual previz and photoreal look development outside console cue authoring.
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
Integrated plot generation and documentation export derived from the same fixture and geometry inputs.
Built for fits when lighting designers need repeatable calculations plus paperwork export for room and façade projects..
AGi32
Editor pickAGi32’s lighting design workflow links fixture photometry to calculation and documentation outputs in one repeatable pipeline.
Built for fits when lighting designers need consistent fixture photometry inputs and fast paperwork exports for repeated spaces..
ReluxDesktop
Editor pickNative fixture-to-photometric workflow drives calculation and render outputs from one managed layout.
Built for fits when lighting design teams need repeatable documentation and rendered validation from fixture selections..
Related reading
Comparison Table
DIALux evo
architectural specialistArchitectural lighting design software for indoor, outdoor, and daylight planning with photometric calculation.
Integrated plot generation and documentation export derived from the same fixture and geometry inputs.
DIALux evo includes fixture library usage for photometric inputs and generates analysis outputs such as illuminance maps and summary results tied to the model context. The workflow supports fixture placement and basic channel hookup style thinking at the layout level, even when full show control is out of scope. Reporting outputs are geared toward lighting paperwork rather than show software deliverables.
The tradeoff is that DIALux evo focuses on lighting engineering outcomes, so it does not replace console programming, cue stack building, or tracking backup workflows. It fits best when a design team needs fast iterations on room-level layouts and then must export consistent paperwork from the same calculations that produced the results.
- +Strong lighting-document export tied directly to calculation results
- +Fixture placement workflow stays centered on lighting engineering outputs
- +Illuminance and coverage outputs support quick design iteration
- +Project model changes propagate to generated plots
- –Not built for DMX cue stack creation or console transfer
- –Automation and integration depth are limited compared with show-control tools
- –Complex scene orchestration needs external tooling
Independent lighting designers
Room layout verification and documentation
Consistent deliverables with fewer reworks
Lighting design offices
Standardized project templates
Faster turnaround across comparable jobs
Show 1 more scenario
Architectural project teams
Facade and interior lighting studies
Clearer decision support in reviews
Run lighting calculations tied to room geometry and generate summary plots for reviews.
Best for: Fits when lighting designers need repeatable calculations plus paperwork export for room and façade projects.
AGi32
architectural specialistProfessional lighting calculation software for architectural, roadway, and daylight analysis.
AGi32’s lighting design workflow links fixture photometry to calculation and documentation outputs in one repeatable pipeline.
AGi32 is most useful when a design process depends on consistent fixture photometry inputs and repeatable calculations tied to a specific layout and patching approach. The software supports generation of outputs such as illumination results and paperwork exports that can be used for review and construction documentation. It also fits designers who need a single workspace for fixture placement plus reporting outputs rather than splitting work across multiple tools. Integration depth is strongest inside the lighting design chain, not as a general CAD replacement.
A tradeoff is that AGi32’s automation and extensibility surface is not positioned as a developer-first API workflow. Manual steps can still be needed when transferring work to CAD drawings or when aligning complex project-specific conventions. It fits situations like recurring hospitality or retail lighting packages where designers iterate layouts and must keep reports consistent across versions.
- +Fixture-library centered workflow keeps photometry inputs consistent across revisions.
- +Design results map directly into paperwork and plot-ready documentation outputs.
- +Iteration over layout and fixture changes reduces report rework.
- +Visualization and calculation outputs support client and technical review cycles.
- –Automation via API and programmatic control is not a primary workflow.
- –Complex project conventions may require manual alignment when exporting to drawings.
- –Best results depend on maintaining accurate fixture library selections.
- –Cross-platform integration tends to be workflow-based rather than schema-based.
Hospitality lighting designers
Revising room layouts across package sets
Faster design iteration cycles
Retail design studios
Producing tenant-ready documentation
More consistent paperwork sets
Show 1 more scenario
Architectural lighting consultants
Client review with calculated results
Clearer review handoffs
Use calculated outputs to support walkthrough discussions and export documentation for technical stakeholders.
Best for: Fits when lighting designers need consistent fixture photometry inputs and fast paperwork exports for repeated spaces.
ReluxDesktop
architectural specialistLighting design and simulation software for buildings, interiors, outdoor spaces, and emergency lighting.
Native fixture-to-photometric workflow drives calculation and render outputs from one managed layout.
ReluxDesktop is designed for end-to-end lighting layout work, from placing fixtures and managing photometric data to generating results for paperwork export. The fixture library workflow reduces friction between a chosen luminaire and the scene where that luminaire must be validated. Rendering feedback supports iterative refinement before documentation is exported. This fit is strongest when design deliverables depend on consistent scene setup and repeatable calculation runs.
A key tradeoff is limited fit for production timecode workflows, where cue stacks, tracking backup, or console transfer are primary requirements. ReluxDesktop is a strong choice for architectural and stage-focused lighting documentation cycles that need renderable outputs and measured plot artifacts rather than show-control sequencing. In projects with heavy CAD round-tripping, the DWG import and export path can become a bottleneck.
- +Fixture library workflow connects selections to photometric calculations
- +Visualization output supports iterative design review without manual scene rebuilding
- +Plot generation supports repeatable documentation from the same layout data
- +Project files keep lighting intent consistent across revisions
- –Limited coverage of show-control tooling like cue stacks and timecoded sequences
- –CAD round-tripping can add overhead for DWG-heavy workflows
- –Automation depends more on workflow consistency than an extensible API surface
- –Some specialized production outputs require external post-processing steps
Architectural lighting designers
Generate renderable lighting documentation
Faster sign-off on design intent
Lighting design studios
Rework fixture layouts across revisions
Fewer mismatched drawings
Show 2 more scenarios
Stage designers
Validate lighting plans prebuild
Lower on-site rework
Uses photometric-based visuals to sanity-check placements before paperwork handoff.
Project managers
Standardize deliverables per job
More consistent output quality
Relies on repeatable project structure to generate documentation at each milestone.
Best for: Fits when lighting design teams need repeatable documentation and rendered validation from fixture selections.
Blender
general 3DOpen source 3D creation software with lighting, rendering, and scene visualization capabilities.
Python automation for scene generation and custom render outputs tied to a controllable render pipeline.
Blender is distinct in the lighting design workflow because its animation and rendering stack lives in a single modeling plus visualization environment. The software supports fixture-oriented scene building with geometry, material shading, and camera animation, then generates photoreal output through its ray tracing engines.
Lighting work is practical for previz and focus studies using imported reference media, view layouts, and repeatable scene assets. Blender is less aligned with console-style programming features like DMX/RDM patch automation and cue stack authoring.
- +Integrated modeling, animation, and ray-traced lighting in one scene graph
- +High-quality photoreal render outputs for lighting look development
- +Extensible workflow through Python scripting and render pipeline hooks
- +Strong asset reuse for fixture geometry and reusable scene templates
- –Limited native cue stack and console transfer workflow compared to lighting tools
- –DMX512 and sACN universe mapping workflows are not native for patch management
- –Precise photometric accuracy depends on manually curated assets
- –Lighting-only fixture libraries and paperwork exports require extra work
Best for: Fits when designers need visual previz and photoreal look development outside console cue authoring.
Visual
architectural specialistInterior and exterior lighting calculation software for architectural design and layout analysis.
Configuration-driven project reuse that keeps fixture, patch, and cue structure consistent across revisions.
Visual builds and manages lighting design data, then generates deliverables for previsualization workflows used by lighting teams. It emphasizes an organized fixture library, patch list handling, and cue structure so designers can reuse designs across revisions.
It also supports importing and exporting common lighting design artifacts used inhandoff processes between design tools and production workflows. For automation and integration, it focuses on configuration-driven reuse of projects rather than custom code workflows.
- +Structured cue and patch workflows reduce rework across revisions
- +Fixture library management supports consistent symbols and attributes
- +Export-oriented workflow fits common paperwork and handoff needs
- +Project configuration enables repeatable previsualization runs
- –Limited depth for advanced raytrace rendering workflows
- –Integration surface relies more on configuration than open APIs
- –External CAD exchange support can be narrower than CAD-first tools
- –Automation needs can stall when custom formats are required
Best for: Fits when teams need repeatable lighting projects with consistent fixture and cue management.
LightCalc
SMBWeb-based architectural lighting calculation software for interior and exterior layouts.
Paperwork export generation that stays synchronized with fixture setup changes after recalculation.
LightCalc targets lighting designers who need rapid cue and paperwork workflows around patched fixtures and calculated photometrics. Its core capability centers on building a fixture setup from known optics and then generating design outputs such as plot deliverables and documentation from that data.
The tool is designed for day-to-day lighting engineering tasks like patch list management and repeatable revisions that stay consistent across documents. Output generation workflows are intended to reduce manual re-keying between design changes and exported paperwork.
- +Paperwork-first workflow ties patch decisions to consistent exports.
- +Fixture optics and photometric inputs support repeatable recalculation cycles.
- +Designed around plot and documentation outputs for lighting engineering.
- +Revision cycles stay less error-prone when changes propagate to exports.
- –Limited direct interoperability with console cue stacks for transfer workflows.
- –DMX address planning features are not as deep as console-grade tools.
- –Visualization and raytrace rendering are not the primary focus.
- –Complex channel hookup edits can require extra manual passes.
Best for: Fits when lighting designers need fast, repeatable patch-to-paperwork output for projects.
Avolites Titan
live eventsConsole software suite featuring a built-in visualizer and fixture library management for stage lighting.
Titan's show-file to console transfer workflow preserves programming structure from offline work to live playback.
Avolites Titan is built around Avolites console workflows, with patching, cue stacking, and playback behavior aligned to how shows are actually run. The software focuses on importing lighting data, generating offline paperwork, and supporting realistic previsualization workflows that match Titan console expectations.
Fixture management and programming tools are designed to move from design intent into transferable console content without requiring external glue. Automation support is strongest through Titan's show file structure and transfer-centric workflow rather than through a generic third-party automation API.
- +Titan show-file workflow matches console transfer expectations for programming continuity
- +Strong fixture library and patch workflow reduces mismatch between design and playback
- +Offline paperwork export supports repeatable show handoff and rehearsals
- +Previsualization workflow fits typical design and revision loops
- –Automation and API surface is weaker than code-first lighting design tools
- –Extensibility depends more on Titan conventions than open external data models
- –Some integration paths require manual mapping across external drafting tools
- –Large projects can feel heavy without careful library and template discipline
Best for: Fits when console-aligned design teams need offline programming and repeatable paperwork export.
Lightkey
vertical specialistMac-native DMX lighting control and design application with a 3D stage view.
Designer-focused cue workflow that keeps patch context linked to documentation exports during show iterations.
Lightkey targets lighting designers who need to turn a fixture library into an actionable cue workflow and technical paperwork. The core value centers on patching structure, show data management, and export paths that support downstream design and programming tasks.
The tool also focuses on keeping cue-related information consistent across iterations, rather than only viewing renders. Lightkey is best evaluated on how well its import, fixture metadata, and documentation exports match a typical designer-to-console handoff.
- +Cue workflow data stays organized from patch to documentation export
- +Fixture library and metadata support faster re-patching across revisions
- +Export options reduce manual re-entry during console handoff
- +Design-review outputs help catch patch and channel mapping mistakes early
- –Workflow coverage is strongest for designer-side tasks, not console-level authoring
- –Automation and API surface are limited compared with tooling built for integration
- –Some advanced previsualization and rendering features are not the focus
- –Complex multi-universe shows can require more manual structuring
Best for: Fits when lighting designers need structured cue data plus repeatable paperwork exports for handoff.
QLC+
open sourceOpen-source DMX lighting control software with a 3D fixture designer and stage simulator.
End-to-end patch-to-scene control lets fixtures map to channels and play through configured DMX drivers without a separate console transfer step.
QLC+ builds lighting control scenes from fixture patches, then drives DMX512 output through a configured driver. The software supports a fixture library workflow with channel-level control and cue playback with a cue stack style timeline.
QLC+ also provides offline media workflows through visualization-friendly scene authoring and exportable paperwork outputs. Governance stays lightweight, since RBAC and audit logs are not core features for multi-user studio administration.
- +Cue scenes and channels connect directly to DMX output
- +Fixture patching supports practical channel hookups for real rigs
- +Offline scene authoring reduces on-stage trial time
- +File-based project management supports handoff to collaborators
- –Offline editor depth can lag console-style cue stack workflows
- –Multi-user governance is limited without studio RBAC and audit logs
- –Automation integrations like OSC or MTC are not a primary workflow
- –Visualization and rendering fidelity depends on external tooling
Best for: Fits when small teams need repeatable scene playback with offline patching and quick DMX output.
Daslight 4
vertical specialistDMX lighting software with a 3D visualizer and scene-based design workflow.
Cue stack editing with show-oriented playback states, tuned for day-to-day busking and precise cue timing control.
Daslight 4 is a lighting designer software package designed around cue sequencing, show control, and fixture patching workflows for live rigs. It provides a built-in editor for building cue lists and a runtime that can drive DMX512 output through Art-Net or sACN style network control.
Daslight 4 also includes visualization and documentation outputs used for previsualization and paperwork export during programming. For designers who need console-to-show transfer and offline editing, it supports structured cue projects that align with typical stage control pipelines.
- +Cue stack workflow supports fast timeline-based show programming
- +Fixture patching tools help maintain a consistent channel hookup
- +Visualization output supports stage rehearsal review before load-in
- +Network DMX output fits installations using Art-Net or similar transport
- –Extensibility and automation depend heavily on external toolchains
- –Complex rig management can become time-consuming on large universes
- –Advanced admin controls for multi-user governance are limited
- –Offline editor workflow is strong but console transfer options can be narrow
Best for: Fits when a lighting designer needs practical cue sequencing with network DMX control and rehearsal-ready exports.
Conclusion
After evaluating 10 art design, 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 lighting designer software
Lighting designer software maps fixture photometry into repeatable layouts, calculations, and documentation, then connects those design outputs to either show playback tools or offline scene preparation. This guide covers DIALux evo, AGi32, ReluxDesktop, Blender, Visual, LightCalc, Avolites Titan, Lightkey, QLC+, and Daslight 4 based on their fixture workflows, export behaviors, and show-control alignment.
The standout split across the list is whether the software centers paperwork and plot generation from the design inputs or whether it preserves programming structure for console transfer and timecoded playback. DIALux evo leads for integrated plot generation and documentation export derived from the same fixture and geometry inputs, while Avolites Titan focuses on show-file to console transfer that preserves programming structure.
Lighting designer software for fixture photometry, documentation exports, and cue-to-show workflows
Lighting designer software takes fixture selections and a modeled layout and then generates lighting calculations and documentation outputs that stay tied to the fixture and geometry inputs. DIALux evo exemplifies this integration by linking plot generation and documentation export to the same fixture and geometry inputs.
Some tools extend that design-to-documentation pipeline with stronger rendering and automation hooks for visual validation. Blender supports Python-driven scene generation and ray-traced lighting in one scene workflow, while Avolites Titan shifts emphasis toward show-file workflows that preserve programming structure from offline work to live playback.
Lighting design workflow controls: calculation-to-documentation and cue-to-show handoff
Lighting designer software earns its place when the same fixture selections and layout inputs drive both lighting calculations and the outputs teams reuse for drawings and revisions. DIALux evo leads here by tying integrated plot generation and documentation export to the same fixture and geometry inputs.
Integrated plot generation and documentation export
DIALux evo generates plots and paperwork from the same fixture and geometry inputs, so room and façade documentation stays synchronized with calculation inputs. AGi32 and ReluxDesktop also keep fixture-library-driven outputs connected to documentation and render validation, but DIALux evo emphasizes repeatable plot generation tied directly to those inputs.
Repeatable fixture library workflow for revisions
AGi32 centers a fixture-library workflow that links photometry inputs to calculation and paperwork export for repeated spaces. ReluxDesktop also uses a native fixture-to-photometric workflow that drives render outputs from one managed layout.
Cue and show iteration support for offline programming
Daslight 4 provides cue stack editing with show-oriented playback states tuned for day-to-day busking and precise cue timing control. Lightkey keeps cue workflow data organized from patch through documentation export for designer-side show iterations.
Console-aligned transfer that preserves programming structure
Avolites Titan focuses on show-file to console transfer to preserve programming structure from offline work into live playback. QLC+ supports patch-to-scene control that maps fixtures to channels and DMX output without a separate console transfer step, which suits small-team offline playback.
Rendering and previsualization automation for look development
Blender uses a Python automation surface to generate scenes and ray-traced lighting in one scene workflow for photoreal lighting look development. ReluxDesktop pairs fixture-driven layouts with visualization output for iterative design review without manual scene rebuilding.
Paperwork-first exports synchronized after recalculation
LightCalc prioritizes paperwork export generation that stays synchronized with fixture setup changes after recalculation. DIALux evo and AGi32 can also keep outputs aligned with design changes, but LightCalc’s workflow centers exports as the primary deliverable.
How to choose lighting designer software based on output ownership and automation needs
The first fork is whether the software should own the design-to-documentation deliverables in one environment. DIALux evo and AGi32 keep paperwork and plot output tied to fixture and photometry inputs so revisions reuse the same calculation pipeline.
Select the workflow owner for your deliverables
Choose DIALux evo when plots and paperwork export must be derived from the same fixture and geometry inputs used for calculation. Choose AGi32 when fixture photometry consistency and repeatable paperwork exports for repeated spaces matter more than console-aligned transfer.
Decide how cue structure moves from offline work to playback
Choose Avolites Titan when show-file to console transfer must preserve programming structure for live playback. Choose Daslight 4 or Lightkey when the workflow prioritizes designer-side cue sequencing with documentation exports and rehearsal-ready cue timing control.
Match rendering depth to review cadence
Choose Blender when lighting look development needs Python-driven scene generation plus ray-traced lighting outputs inside a controllable scene pipeline. Choose ReluxDesktop when fixture-driven visualization for iterative design review must come from the same managed layout without scene rebuilding.
Check automation surface expectations versus manual alignment needs
Choose Blender when automation expects code-level control through Python-driven scene generation and custom render outputs. Choose Visual when project reuse depends on configuration-driven fixture, patch, and cue structure rather than open API programmatic control.
Validate paperwork synchronization behavior after design changes
Choose LightCalc when paperwork export generation is the primary workflow deliverable and export output must stay synchronized after recalculation. Choose DIALux evo when synchronized paperwork export must be coupled with plot generation from the same fixture and geometry inputs.
Plan around toolchain dependency for large-rig DMX realities
Choose Daslight 4 when timeline-based cue stack editing must support rehearsal-ready cue sequencing, then manage large-universe complexity through supporting toolchains. Choose QLC+ when offline patch-to-scene control must map fixtures to channels and play through configured DMX drivers with minimal console-transfer steps.
Who benefits from each lighting designer workflow pattern
Lighting teams with heavy documentation loads benefit from tools that produce plot and paperwork outputs directly from fixture and geometry inputs without switching pipelines. Designers who also need to preserve programming continuity for show playback benefit from show-file transfer workflows.
Lighting design firms producing repeated room or façade documentation
AGi32 keeps fixture-library photometry inputs consistent and maps design results into repeatable paperwork exports for repeated spaces. DIALux evo also centers repeatable plot generation and documentation export derived from the same fixture and geometry inputs.
Console-aligned design teams doing offline programming and live handoff
Avolites Titan preserves programming structure from offline show work into live console transfer through its show-file workflow. Lightkey and Daslight 4 suit designer-side cue iteration when cue timing control and paperwork export are part of the designer workflow.
Small production teams needing DMX-ready offline operation
QLC+ supports end-to-end patch-to-scene control so fixtures map to channels and play through configured DMX drivers without a separate console transfer step. Daslight 4 also supports cue stack editing tuned for busking and precise cue timing control.
Teams focused on photoreal lighting look development and render output iteration
Blender supports Python automation for scene generation and ray-traced lighting outputs tied to a controllable scene pipeline. ReluxDesktop supports fixture-to-photometric layout workflows that drive visualization output for iterative review.
Studios that standardize fixture, patch, and cue structure across many revisions
Visual uses configuration-driven project reuse that keeps fixture, patch, and cue structure consistent across revisions. Its fixture library management supports consistent symbols and attributes to reduce rework.
Common lighting designer software pitfalls during tool selection
A frequent failure mode is choosing a documentation-first tool when the actual requirement is console cue stack creation and show-control transfer. DIALux evo can generate plot and documentation exports but is not built for DMX cue stack creation or console transfer.
Buying a plot-first workflow tool for show-control deliverables that require cue stack creation.
DIALux evo is strong for integrated plot generation and paperwork export but does not provide a DMX cue stack creation or console transfer workflow. Avolites Titan is the better match when show-file to console transfer must preserve programming structure.
Assuming automation and API control are equal across all fixture-to-documentation tools.
AGi32’s automation via API and programmatic control is not a primary workflow compared with its fixture-library-centered pipeline. Blender provides Python automation as a first-class workflow surface for scene generation and custom render outputs.
Selecting a visualization pipeline without checking how cue stacks and timecoded sequences are handled.
ReluxDesktop supports fixture-driven calculation and visualization outputs but has limited coverage of show-control tooling like cue stacks and timecoded sequences. Daslight 4 supports timeline-based cue stack editing geared toward show-oriented playback states.
Overlooking governance and multi-user controls in tools that are not studio RBAC oriented.
QLC+ notes limited multi-user governance without studio RBAC and audit logs. Visual uses configuration-driven reuse, which reduces revision errors but does not replace explicit governance controls for multi-user studio environments.
Expecting large-universe rig management to stay lightweight inside a cue-centric tool.
Daslight 4 notes complex rig management can become time-consuming on large universes. QLC+ supports patch-to-scene operation with channel hookups to configured DMX drivers, but offline editor depth can lag console-style cue stack workflows.
How We Selected and Ranked These Tools
We evaluated each lighting designer software by how directly fixture selections and layout inputs drive calculation and documentation outputs, by ease of repeating those outputs across revisions, and by how well the automation and integration surface supports real workflow execution. Feature coverage accounted for 40% of the ranking because plot generation and export behaviors determine whether paperwork stays synchronized with design inputs.
Ease and value each accounted for 30% because teams must reuse fixture-library workflows and avoid manual alignment during drawing exports and project updates. DIALux evo ranked highest because integrated plot generation and documentation export were derived from the same fixture and geometry inputs, which reduces handoff errors compared with tools that separate visualization, paperwork, or show-control workflows.
Frequently Asked Questions About lighting designer software
Which tools keep fixture photometry aligned with paperwork export without manual re-keying?
How does AutoCAD-based geometry handoff differ from a dedicated lighting desktop workflow in DIALux evo and Blender?
When is a photometric-based workflow more reliable than cue-driven editing for repeatable layout iteration?
What breaks if a team needs console-aligned cue structure instead of designer-centric documentation exports?
How do SSO and multi-user security controls compare across QLC+ and the designer-focused desktop tools?
Which toolchain supports network DMX control during rehearsal using Art-Net or sACN style output?
How does data migration work when moving a fixture library and patch list into another tool, for example from Visual or Lightkey?
When does extensibility matter for automating scene generation, and which tool offers a programmable pathway?
What tradeoff appears when choosing QLC+ for end-to-end patch-to-scene control versus Avolites Titan for console transfer?
Which workflow is best for generating plot and paperwork deliverables from the same inputs, including geometry-driven calculations?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
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→