GITNUXSOFTWARE ADVICE
Technology Digital MediaTop 10 Best Pixel Led Software of 2026
Top 10 pixel led software ranked for teams using Evidently AI, Weights & Biases, and MLflow, with technical tradeoffs and notes.
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
Lightkey is the best pick when you need deterministic pixel mapping and an effect timeline that compiles cleanly for hardware displays, whereas Falcon Player is a strong alternative if your team wants repeatable pixel-mapped playback with controlled operator handling.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Lightkey
A mapping-first workflow that compiles grouped pixel layouts into controller-ready output sequences with predictable per-pixel addressing.
Built for fits when teams need deterministic pixel mapping and effect timeline compilation for hardware displays..
Falcon Player
Editor pickCompiled pixel output tied to a visual matrix and timeline editor for consistent show playback.
Built for fits when teams need repeatable pixel-mapped effects with controlled playback across operators..
Light-O-Rama
Editor pickChannel-based sequence authoring with pixel grouping that compiles into controller-ready output plans.
Built for fits when show teams need deterministic sequence compilation tied to fixed controller wiring..
Comparison Table
Lightkey
SMBDMX lighting control with built-in pixel mapping.
A mapping-first workflow that compiles grouped pixel layouts into controller-ready output sequences with predictable per-pixel addressing.
Lightkey targets teams that need pixel matrix layout control plus a deterministic effect timeline that can be previewed and then mapped for the installed topology. The workflow includes pixel grouping, layout-to-output mapping, and export-style compilation for LED controller firmware workflows. For integration depth, Lightkey can connect to common ML experimentation tooling through data-driven color and effect iteration loops using external evaluation artifacts and run logs.
A key tradeoff is that Lightkey prioritizes mapping fidelity and timeline authoring over deep studio-grade media pipelines like advanced color-managed compositing. In a typical setup, the tool is used to define the pixel matrix layout, validate colors with gamma-correct behavior during preview, then push sequences through an automation-friendly path tied to controller configuration endpoints.
- +Pixel grouping and layout mapping are detailed enough for complex installs
- +Effect timeline authoring supports repeatable sequence compilation for hardware output
- +Fixture profile handling reduces trial-and-error during color calibration
- +Integration-friendly workflow supports ML iteration loops with experiment outputs
- –UI friction increases when editing large pixel matrices and dense wiring maps
- –Advanced media import paths are limited versus specialized animation packages
ML experimentation teams
Iterate effects using experiment logs
Faster iteration without remapping
Installation technical directors
Convert wiring layouts into outputs
More reliable show playback
Show 2 more scenarios
MLflow-based automation teams
Publish sequence variants from runs
Repeatable deployments
Run artifacts can guide generation of repeatable sequence outputs tied to controller configuration.
Weights and Biases workflows
Compare color and effect trials
Traceable visual tuning
Trial metadata can track configuration changes while keeping the pixel layout consistent.
Best for: Fits when teams need deterministic pixel mapping and effect timeline compilation for hardware displays.
Falcon Player
vertical specialistOpen-source show player for running pixel light sequences.
Compiled pixel output tied to a visual matrix and timeline editor for consistent show playback.
Falcon Player fits teams that need an effect timeline editor tied to an explicit LED pixel matrix layout. It handles controller endpoint configuration and pixel grouping so a physical wiring plan maps cleanly to a logical grid. It is a good match when the same project needs predictable playback behavior across rehearsals and multiple operators.
A key tradeoff is that higher-fidelity mapping and timing control takes more up-front configuration than simpler DMX-only workflows. Falcon Player works best when mapping accuracy is treated as part of the production process rather than an afterthought, such as when building repeatable stage visuals from a defined fixture profile and pixel density calibration.
- +Timeline effects align directly with explicit pixel matrix layouts
- +Pixel grouping and controller endpoint configuration reduce mapping repetition
- +Compiled output improves consistency for repeatable playback
- +Integration workflow fits teams using external ML experiment tracking
- –Deep mapping configuration increases setup time for new shows
- –Advanced output tuning has a steeper learning curve than basic playback tools
Stage visuals engineers
Create timeline-driven pixel wall effects
Consistent wall playback each run
Event production technical directors
Reuse fixture profiles across shows
Lower remap effort between venues
Show 2 more scenarios
ML experiment integration teams
Turn model outputs into LED scenes
Auditable visual iteration loop
Coordinate experiment runs and tracked metrics to drive repeatable scene parameters in Falcon Player workflows.
Multi-operator show crews
Standardize operator playback behavior
Fewer playback mistakes
Use compiled project states so operators trigger scenes with minimal risk of ad hoc changes.
Best for: Fits when teams need repeatable pixel-mapped effects with controlled playback across operators.
Light-O-Rama
SMBLighting show control software with a dedicated Pixel Editor for RGB pixel string sequencing.
Channel-based sequence authoring with pixel grouping that compiles into controller-ready output plans.
Light-O-Rama’s core capability is an effect timeline tied to channel-level output, where pixel groups are defined and then used to generate show playback. Mapping and layout work are oriented toward getting physical LED topology into a deterministic pixel-to-channel relationship that can be driven by show sequences. Controller endpoint configuration connects those compiled outputs to actual networked or controller-attached endpoints through established output modes. This structure favors repeatability across shows that reuse the same physical fixture plan.
A key tradeoff is that pixel mapping and fixture modeling require upfront attention, because the quality of the final look depends on the correctness of the pixel grouping and layout. For teams that frequently rewire panels or change cascade order, the maintenance burden of mapping updates can become the dominant time cost. A typical usage situation is a seasonal installation where sequences evolve each show but the underlying pixel layout stays stable.
- +Sequence timeline compiles deterministic channel output for repeatable shows
- +Pixel grouping and layout planning translate into consistent visual effects
- +Controller endpoint configuration ties sequences to concrete show outputs
- +Workflow supports iterative show updates without rebuilding the whole plan
- –Pixel mapping updates are time-consuming when physical wiring changes
- –Automation and external integration require more manual steps than script-first tools
- –Advanced network output setup can be harder to validate without hardware testing
- –High channel counts increase authoring workload during layout refinement
Holiday display production teams
Reuse sequences across fixed pixel layouts
More repeatable show playback
Architectural lighting installers
Map physical LED groupings to outputs
Fewer visual mismatches
Show 1 more scenario
Small operations teams
Manage controller endpoint configuration
Faster show iteration
Teams configure endpoints once and then iterate sequences using the same output model.
Best for: Fits when show teams need deterministic sequence compilation tied to fixed controller wiring.
xLights
SMBOpen-source sequencing software for animated lighting displays.
Unified mapping and sequence compilation pipeline that keeps fixture layout, pixel grouping, and controller output aligned in one project.
xLights is LED mapping and pixel sequence software built around an effect timeline editor and a controller-aware output mapping workflow. It supports pixel channel assignment through node and fixture configuration tools, then compiles sequences to match controller endpoints and wiring topologies.
The toolchain centers on repeatable show projects with simulation, playlist-like playback workflows, and export paths for controller control. xLights is distinct in how tightly its mapping, preview, and sequence compilation stages connect into one project model.
- +Effect timeline editor that ties directly into compiled controller output mapping
- +Simulation and preview workflows that validate mapping before running fixtures
- +Flexible pixel grouping for complex LED layouts and fixture types
- +Strong show authoring pipeline from mapping to sequence compilation
- –Initial setup requires careful controller endpoint configuration discipline
- –Large projects can feel slower to iterate during mapping changes
Best for: Fits when teams need an end-to-end mapping to sequence compilation workflow with tight preview checks.
Resolume
enterpriseVJ software with advanced pixel mapping for LED fixtures.
Layered, timeline-based rendering with live parameter control while sending frames to Art-Net or sACN destinations.
Resolume performs real-time LED and pixel output through a stage and performance control workflow centered on a timeline-driven effect editor. It supports mapping for pixel channel assignment and output via common broadcast lighting protocols like Art-Net and sACN E1.31, then routes visuals to LED controller firmware targets. Complex LED installations are handled through layered compositions, per-pixel grouping, and live adjustments that update the frame output during playback.
- +Live effect timeline enables deterministic playback for pixel-mapped LED shows
- +Art-Net and sACN output workflows cover common LED controller network setups
- +Pixel grouping and layered compositing support fast iteration during rehearsals
- +Mapping grid controls help align pixel density and layout decisions
- –Pixel mapping and installation wiring logic require careful preplanning
- –API extensibility for automation is limited versus code-first visualization stacks
Best for: Fits when live teams need timeline playback for mapped LED graphics.
Vixen Lights
SMBFree sequencing application for animated holiday lighting.
Single authoring flow that links effect timeline editing to controller mapping compilation for show-ready output.
Vixen Lights targets LED mapping and pixel sequence creation for shows that need controllable timing and repeatable layout. It provides an effect timeline workflow with device and pixel configuration that can compile mappings into controller-ready output.
The software focuses on practical pixel-to-fixture addressing and show control, with support for common lighting control protocols used in pixel installations. Vixen Lights is distinct for keeping the editing and mapping steps inside one show authoring flow rather than splitting them across multiple tools.
- +Effect timeline editing ties directly to device and pixel layout
- +Pixel grouping and mapping setup supports large show structures
- +Controller-oriented compilation reduces manual rework between runs
- +Protocol support fits common pixel controller endpoints used in installs
- –Advanced channel assignment still needs careful setup discipline
- –Automation and API surface is limited for ML pipelines and external orchestration
- –Large layouts can require extra mapping effort before first live output
- –Integration for external experiment tracking tools is not native
Best for: Fits when show authors need an integrated editor for pixel layouts and repeatable show output without custom orchestration.
WLED
vertical specialistWeb-based firmware for controlling addressable LED strips.
Built-in segment and mapping workflow with a web interface plus HTTP API for remote automation.
WLED is pixel LED firmware centered on fast, web-based control of addressable strips and matrices. It focuses on in-controller effects, real-time color updates, and practical network protocols for driving LEDs from external devices.
WLED also supports detailed per-output settings and mapping tools that help convert physical wiring into a predictable pixel layout. For teams building repeatable lighting systems, it provides an API and configuration workflow that fit controller provisioning and automation.
- +Web UI updates pixel colors with low friction using a built-in control surface
- +Extensive effect engine settings, including palettes and timing, without external tooling
- +HTTP API enables automation scripts to set segments, presets, and brightness
- +Mapping helpers reduce mismatch risk between physical wiring and logical layout
- –Advanced pixel mapping workflows still require careful setup to match topology
- –Multi-layer sequences can become hard to debug when multiple segments overlap
- –Throughput is constrained by controller hardware when driving very dense pixel counts
- –Protocol handling like Art-Net can add complexity in large multi-node deployments
Best for: Fits when a team needs a controller firmware with an API for repeatable pixel effects and mapping.
LedStrip Studio
vertical specialistSoftware for designing and controlling LED strip and pixel animations via ArtNet, sACN, and direct output.
Grouped pixel editing inside the pixel matrix grid reduces rework when layout changes mid-project.
LedStrip Studio targets pixel LED mapping and effect authoring for WS2812-style pixel tape and related controller outputs, with an interface built around a visual pixel matrix workflow. Core capabilities include a layout grid for pixel channel assignment, per-pixel grouping for easier edits, and an effect timeline editor for sequencing and previewing output.
The tool also supports mapping exports for driving LED controller firmware and helps operators manage color behavior using gamma correction settings. Teams that need repeatable mappings for shows and installations can use its configuration-oriented workflow to keep controller endpoint configuration consistent across projects.
- +Pixel matrix layout editor makes pixel grouping and re-mapping fast
- +Effect timeline editor supports repeatable sequences with preview feedback
- +Gamma correction controls help reduce color banding on real fixtures
- +Export-oriented workflow supports controller endpoint configuration
- –Advanced mapping features like complex node topology need careful manual setup
- –Effect preview quality depends on matching refresh rate and pixel order
Best for: Fits when teams need visual pixel mapping and timeline sequencing for WS2812-style strips.
QLC+
open sourceOpen-source lighting control software supporting E1.31 and ArtNet output for pixel LED arrays.
Cue-based show control that ties pixel mapping to timed effect playback, with built-in sequence editing for mapped channels.
QLC+ turns a pixel LED layout into timed output by combining patching, mapping, and a show sequencer for real controllers. It supports pixel addressing workflows with mapping grids, channel assignment, and fixture profiles used during export and runtime output.
QLC+ also coordinates network lighting protocols with endpoint configuration so a pixel matrix can be driven from Art-Net or sACN sources and merged priorities. Its core strength is translating a physical pixel layout into actionable playback steps without requiring a custom visualization pipeline.
- +Pixel mapping workflow with grid-based layout and repeatable fixture profiles
- +Show sequencer that drives timed effects across mapped channels
- +Art-Net and sACN network output support for controller endpoint configuration
- +Effect timeline authoring built around cues and playback states
- –Deep pixel topology setup can take multiple passes for large matrices
- –No dedicated automation hooks for external ML pipelines like Evidently AI
- –Limited advanced data model controls for pixel groups and schema-like validation
- –Performance tuning for refresh rate is manual and easy to misconfigure
Best for: Fits when a lighting team needs sequenced pixel playback from a mapped layout with Art-Net or sACN output.
SanDevices
vertical specialistEthernet pixel LED controllers with web-based configuration for E1.31 streaming to pixel strings.
A layout-to-channel workflow that produces deterministic hardware-ready pixel mapping from a designed matrix.
SanDevices targets pixel LED control setups that need software-driven mapping, fixture layout planning, and repeatable output generation. It focuses on converting a designed pixel matrix layout into controller-ready channel assignments and sequence output for real LED hardware.
Teams using MLflow, Evidently AI, and Weights and Biases for model iteration can use the workflow to keep experiment artifacts aligned with deterministic rendering parameters. The main distinctiveness is its end-to-end pathway from pixel layout design to hardware output configuration for firmware running on controllers.
- +Pixel layout to controller channel assignment reduces manual mapping work
- +Deterministic sequence output supports repeatable on-device visual results
- +Works well when controller endpoints and topology are known in advance
- +Supports integration of render parameters into ML experimentation workflows
- –Complex pixel grouping and topology changes require careful setup discipline
- –No clearly documented API surface for programmatic pixel mapping automation
- –Iteration loop with Python ML tooling needs external glue code
- –Large installations can increase configuration time before first output
Best for: Fits when teams need software-generated pixel output that matches a planned layout.
Conclusion
After evaluating 10 technology digital media, Lightkey stands out as our overall top pick — it scored highest across our combined criteria of features, ease of use, and value, which is why it sits at #1 in the rankings above.
Use the comparison table and detailed reviews above to validate the fit against your own requirements before committing to a tool.
How to Choose the Right pixel led software
Pixel led software is where teams convert a designed pixel matrix into controller-ready output sequences, then iterate on the effect timeline with mapping logic tied to playback. This guide covers Lightkey, Falcon Player, Light-O-Rama, xLights, Resolume, Vixen Lights, WLED, LedStrip Studio, QLC+, and SanDevices.
The ranking criteria focus on integration depth with ML pipelines and observability workflows, then on how each tool handles pixel mapping determinism, timeline compilation, and automation surfaces. Each tool review emphasizes the mechanisms that affect repeatability and operator control, including preview alignment, mapping-to-output binding, and how external orchestration fits into the workflow.
Pixel LED Software That Maps Pixel Layouts to Controller Output and Repeatable Timelines
Pixel led software turns a pixel matrix layout into configured channel or segment output that can drive LED controllers with repeatable frame playback. Tools like Lightkey compile grouped pixel layouts into controller-ready output sequences with predictable per-pixel addressing, which reduces drift between design intent and hardware addressing.
Falcon Player also binds pixel effects to an explicit visual matrix and timeline editor so operators can run consistent show playback across mapped endpoints. Across the list, the biggest differences show up in how mapping changes propagate into compiled output, how carefully the UI manages dense wiring and matrix edits, and whether an automation path exists for external workflows such as Evidently AI, Weights & Biases, and MLflow.
Pixel mapping determinism, timeline compilation, and automation surfaces
Pixel led software succeeds when pixel mapping changes produce predictable controller-ready output, not when the preview only looks right. The strongest tools bind pixel grouping and layout mapping directly to effect timeline compilation so the output stays repeatable across operators.
Automation and integration matter when ML pipelines generate or validate content and when operators need controlled show playback across multiple destinations. Tools with a documented API or a clear integration path reduce the manual gap between an ML experiment and a configured pixel output run.
Mapping-first compilation that preserves per-pixel addressing
Lightkey compiles grouped pixel layouts into controller-ready output sequences with predictable per-pixel addressing. It suits teams that need deterministic addressing from layout into the compiled timeline.
Timeline-to-matrix binding for repeatable show playback
Falcon Player aligns effect timeline effects with explicit pixel matrix layouts for consistent playback across operators. It also uses pixel grouping plus controller endpoint configuration to reduce repetitive mapping work.
Unified fixture layout and compiled controller output workflow
xLights keeps fixture layout, pixel grouping, and controller output mapping in one project pipeline so preview checks validate the compiled plan. It fits teams that want tight alignment between mapping and sequence compilation.
Live timeline rendering to network LED destinations
Resolume provides layered, timeline-based rendering with Art-Net or sACN output workflows for mapped LED graphics. It targets live teams that need parameter changes during playback with network-connected controllers.
Controller firmware with a web interface and HTTP API
WLED runs controller firmware with a web interface for low-friction pixel color updates and an HTTP API for remote automation. It fits workflows that prefer controller-side segment and mapping controls rather than only authoring in a separate editor.
Cue sequencer tied to mapped channels with grid layout
QLC+ provides a show sequencer that drives timed effects across mapped channels with grid-based pixel mapping. It fits lighting teams that run cue-based timelines while still managing pixel mapping and fixture profiles.
Choose by compilation model, operator workflow, and integration entry point
The decision starts with how pixel mapping propagates into compiled output, because mapping edits can either recompile deterministically or force slow rework. The next decision is how timeline control is handled, because operators need either compiled repeatability or live parameter control.
The final decision is the automation entry point, because ML pipelines such as Evidently AI, Weights & Biases, and MLflow need a practical path from experiment outputs into pixel playback. Tools differ most in whether automation fits a code-first integration approach, a web/API controller approach, or an editor-first project workflow.
Select the compilation model that matches how mapping changes happen
If layout changes must always produce predictable controller-ready output, pick Lightkey or Falcon Player since both compile pixel grouping tied to explicit layouts. If the show team expects deterministic channel output tied to fixed controller wiring and can tolerate mapping updates being slower, pick Light-O-Rama.
Pick timeline control based on operator playback needs
If playback must stay repeatable across operators with effects aligned to a visual matrix and timeline editor, pick Falcon Player or Vixen Lights. If the team needs live timeline playback with layered parameter control while sending frames to Art-Net or sACN destinations, pick Resolume.
Decide where automation should attach
If automation should call an HTTP endpoint while keeping pixel control in the controller firmware, pick WLED because it combines a web interface with an HTTP API. If automation must stay in the editor workflow and the team accepts a more manual integration effort, pick xLights or QLC+.
Confirm scaling limits for dense matrices and dense wiring maps
If large pixel matrices and dense wiring maps require frequent edits, pick Lightkey carefully since UI friction can increase for dense mapping changes. If large projects feel slower to iterate during mapping changes, pick xLights with expectation of more disciplined controller endpoint configuration.
Match mapping depth to topology complexity
If the project needs complex topology work and manual setup is acceptable, pick LedStrip Studio because advanced mapping like complex node topology can require careful manual setup. If deep pixel topology setup is expected to take multiple passes for large matrices, pick QLC+.
Who should buy which pixel led software
Teams with a stable wiring plan and a strong need for repeatable compiled playback should prioritize tools that tie pixel grouping to controller-ready sequence output. Teams running live shows should prioritize layered timeline rendering and network output workflows that tolerate parameter changes during performance.
Teams connecting ML outputs to pixel playback need an automation path that fits how the experiment artifacts are produced and validated. Tools with an HTTP API or a clear editor workflow reduce the manual work between experiment run artifacts and configured pixel scenes.
Hardware-first show teams running deterministic sequences across operators
Lightkey and Falcon Player both compile pixel mapping and timeline output so operators run consistent playback tied to explicit pixel layouts.
Live performance teams sending frames over Art-Net or sACN
Resolume targets layered timeline playback with Art-Net or sACN output so mapped LED graphics can be controlled during performance.
ML-adjacent teams that want an API-driven control surface for pixel output
WLED provides a built-in web interface and an HTTP API for remote automation so external systems can drive repeatable pixel effects through controller-side segment settings.
Lighting teams that run cue-based show playback with mapped channels
QLC+ ties pixel mapping and fixture profiles to a show sequencer that drives timed effects across mapped channels.
Teams that need pixel layout to controller assignment with minimal manual mapping work
SanDevices focuses on layout-to-channel assignment for deterministic hardware-ready pixel mapping, which reduces manual pixel mapping work when a designed matrix exists.
Common pixel led software pitfalls during mapping and automation setup
Mapping drift is a frequent failure mode when the timeline looks correct but the compiled output no longer matches the intended pixel addressing. Dense matrices also introduce edit-time friction when the tool requires careful endpoint configuration discipline for every controller change.
Automation mistakes happen when teams assume external orchestration is plug-and-play for ML workflows. Some tools emphasize editor-first project management, while others expose an API that supports programmatic control, so the automation plan needs to match the tool’s actual integration surface.
Treating preview output as proof that the compiled controller plan matches hardware addressing
xLights includes simulation and preview workflows that validate mapping before running fixtures, while tools that do not emphasize this can leave addressing mismatches until controller output time.
Switching wiring or topology without planning for how mapping updates propagate into compiled output
Light-O-Rama compiles deterministic channel output tied to fixed wiring, and pixel mapping updates become time-consuming when physical wiring changes, so wiring changes should drive a recompile plan.
Assuming deep automation hooks exist for ML pipelines without checking the integration surface
WLED provides an HTTP API for remote automation, while QLC+ lacks dedicated automation hooks for external ML pipelines like Evidently AI, so an ML workflow may require custom orchestration.
Underestimating setup complexity for dense mapping configuration
Falcon Player’s deep mapping configuration increases setup time for new shows, so teams should allocate time for endpoint configuration discipline before show rehearsals.
Overlapping segments or layers without a debug plan for multi-layer interactions
WLED can become hard to debug when multiple segments overlap, so a separate layer strategy or naming discipline helps prevent unintended blended output.
How We Selected and Ranked These Tools
We evaluated Lightkey, Falcon Player, Light-O-Rama, xLights, Resolume, Vixen Lights, WLED, LedStrip Studio, QLC+, and SanDevices by weighting features at 40% and ease and value at 30% each. Integration depth was scored through how tightly pixel grouping and layout mapping bind into compiled controller output sequences or live network frame output workflows.
Automation and API surface were scored through whether the tool exposes a practical entry point such as WLED’s HTTP API for remote control or an editor workflow that can be integrated with external orchestration. Lightkey ranked highest because its mapping-first workflow compiles grouped pixel layouts into controller-ready output sequences with predictable per-pixel addressing and repeatable effect timeline compilation.
Frequently Asked Questions About pixel led software
How do Lightkey and xLights handle compiling a pixel matrix into controller-ready output?
Which toolchain is better for teams running Evidently AI, Weights and Biases, and MLflow while generating pixel effects?
How does WLED support automation for repeatable pixel mapping across multiple controller deployments?
When a show needs layer-based live playback with immediate frame updates, which software fits best: Resolume or QLC+?
What breaks if a team treats Art-Net and sACN E1.31 mapping as interchangeable without checking priorities and universe alignment?
Where does pixel grouping behave differently across LedStrip Studio and Light-O-Rama during edits mid-project?
How do Falcon Player and Vixen Lights differ in keeping editing and playback logic consistent for operators?
What security and access controls should teams verify when using WLED's web control versus desktop mapping tools like Lightkey?
How should teams plan data migration when moving a pixel mapping project from a matrix layout workflow into a show sequencer?
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
Technology Digital Media alternatives
See side-by-side comparisons of technology digital media tools and pick the right one for your stack.
Compare technology digital media tools→