GITNUXSOFTWARE ADVICE
Technology Digital MediaTop 10 Best Hexa Software of 2026
Top 10 hexa software picks ranked by features and value, with Canva, Figma, Adobe Creative Cloud, plus Hexinator, MadEdit, HexEd.it 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
Hexinator is the go-to choice if you need interactive byte patching with grammar-based binary templates for proprietary formats, whereas MadEdit is the better fit for engineers who want a precise cross-platform hex workflow for manual inspection and small edits.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Hexinator
Integrated CRC validation and checksum calculation directly tied to the edited bytes, reducing verification gaps.
Built for fits when analysts need interactive byte patching, pattern search, and CRC checks on individual files..
MadEdit
Editor pickSynchronized hex plus ASCII views with offset-accurate navigation for fast byte-level root-cause analysis.
Built for fits when engineers need precise hex inspection and small patches without automation dependencies..
HexEd.it
Editor pickSynchronized offset and ASCII interpretation make byte-sequence verification faster during patch edits.
Built for fits when teams need quick hex inspection and byte patching without disassembly overhead..
Related reading
Comparison Table
Hexinator
enterpriseHex editor with grammar-based binary templates for parsing proprietary file formats.
Integrated CRC validation and checksum calculation directly tied to the edited bytes, reducing verification gaps.
Hexinator is built for hands-on binary analysis where the primary interactions are hexdump export, search-and-replace bytes, and byte-level comparison across versions. The editor view ties byte offset navigation to readable ASCII interpretation, which reduces context switching during debugging and patch validation. The automation surface is mostly limited to editor-driven workflows, so API integration and provisioning do not appear to be a first-class integration path.
A key tradeoff is that Hexinator is strongest for file-based inspection and patching rather than large-scale programmatic parsing pipelines. Teams typically fit it when reverse engineers, firmware analysts, and QA engineers need quick checks such as CRC validation and targeted byte edits before rerunning the executable.
- +Fast byte offset navigation for pinpoint patching and verification
- +Search-and-replace bytes works directly against binary content
- +ASCII interpretation alongside hex improves data sanity checks
- +CRC validation and checksum calculation support repeatable checks
- –Automation API and integration surface are limited compared to developer tools
- –Large corpus workflows need manual handling of files
- –Structured data overlay for complex binary formats is not its core focus
- –No governance controls like RBAC or audit logs for team administration
Firmware reverse engineers
Validate CRC after targeted byte patch
Fewer broken firmware builds
QA engineers
Compare two binary revisions
Shorter root-cause time
Show 2 more scenarios
Incident responders
Inspect packet payload signatures
Clear artifact handoff
Navigate by byte offset and export hexdump evidence for consistent review across stakeholders.
Software security testers
Patch executable header fields
Faster controlled repro
Perform search-and-replace bytes around executable headers and recheck checksum values after edits.
Best for: Fits when analysts need interactive byte patching, pattern search, and CRC checks on individual files.
MadEdit
SMBOpen-source cross-platform hex, text, and column editor supporting large files.
Synchronized hex plus ASCII views with offset-accurate navigation for fast byte-level root-cause analysis.
MadEdit fits analysts who need repeatable byte-level inspection rather than image-centric editing. The editor workflow supports byte offset navigation, byte pattern search, and synchronized views for hex and ASCII interpretation. It also supports byte-level comparison workflows for spotting differences at exact positions.
A tradeoff is that MadEdit centers on local editing and inspection rather than multi-user collaboration or full automation pipelines. It works best when a single operator is modifying packet payloads, executable headers, or firmware images and then re-checking the result with validation tooling. It can be less suitable when governance-driven automation or API-driven batch patching is required.
- +Byte-offset navigation for precise edits in large binaries
- +Search supports byte patterns for targeted byte-level changes
- +Synchronized hex and ASCII interpretation speeds anomaly spotting
- +Diff-style comparison helps validate exact patch locations
- –Limited automation and scripting surface for batch patching
- –No built-in RBAC or audit-log controls for shared environments
- –Local workflow focus reduces suitability for distributed operations
- –Structured parsing depth depends on manual annotation rather than schemas
Malware analysts
Inspect executable headers and strings
Fewer offset mistakes during review
Firmware engineers
Patch firmware images safely
Repeatable patching on images
Show 2 more scenarios
Security testers
Modify packet payload bytes
Correct payload for test cases
MadEdit enables byte-level search-and-replace to adjust payload content while preserving framing offsets.
Reverse engineers
Compare binaries to find deltas
Clear diff-driven patch verification
MadEdit supports byte-level comparison so changes are located at the exact byte positions.
Best for: Fits when engineers need precise hex inspection and small patches without automation dependencies.
HexEd.it
API-firstA browser-based hex editor for viewing and modifying local binary files.
Synchronized offset and ASCII interpretation make byte-sequence verification faster during patch edits.
HexEd.it provides a hex editor view paired with ASCII interpretation so byte sequences can be validated against readable characters during analysis. The interface targets common edit loop actions like search, replace, and overwrite at exact byte positions for controlled binary patching. Offset navigation is central, which helps when matching headers, magic numbers, or field boundaries without loading a full disassembler toolchain.
A practical tradeoff is that HexEd.it does not replace dedicated reverse engineering suites for disassembly and executable header analysis at scale. It is a better fit for targeted file signature analysis, quick binary patching, and packet payload inspection where throughput and repeatable edits beat deep program semantics.
- +Offset-driven hex editor navigation for precise byte placement
- +Search and replace across raw bytes supports repeatable patch edits
- +ASCII interpretation side-by-side view speeds human pattern checks
- +File-focused workflow suits quick inspection without extra tooling
- –Limited reverse engineering depth versus disassembly-first editors
- –Complex structured overlays need more manual checking
- –Large-file editing can feel slower than desktop native tools
Firmware maintainers
Verify and patch firmware images
Fewer patch mistakes
Security analysts
Triage packet payload anomalies
Faster incident triage
Show 2 more scenarios
QA automation engineers
Create deterministic binary test fixtures
Stable test inputs
Run search and replace to generate repeatable test artifacts from baseline binaries.
Software release engineers
Spot regressions in shipped assets
Quicker regression localization
Use byte-level comparison loops to find changes in exported hexdump outputs across builds.
Best for: Fits when teams need quick hex inspection and byte patching without disassembly overhead.
HxD
developer toolA Windows hex editor with disk editing, RAM editing, search tools, and checksums.
Offset-centric hex editing with integrated byte comparison makes change verification faster than re-inspecting dumps.
HxD is a hex editor and binary file viewer used for byte-level inspection and editing with a focus on deterministic file offsets. The workflow centers on fast hex dump navigation, byte search and replace, and reliable interpretation helpers for ASCII and structured-looking content.
HxD also supports diff-style byte comparisons and file analysis patterns that fit patching and validation tasks where changes must be explicit. As a hexa tool in a ranked set, it ranks fourth by combining low-friction editing with pragmatic export and verification workflows.
- +Fast byte navigation with stable offset-centric editing workflows
- +Search and replace supports hex patterns for repeatable modifications
- +Byte comparison helps confirm what changed between two binaries
- +Export and interpretation views reduce manual transcription errors
- –Limited automation surface for scripted batch patching workflows
- –Advanced integrity checks rely on manual steps rather than rule-based validation
- –Large disk images and very large binaries can feel slower
- –Extensibility depends on built-in features rather than a public plugin API
Best for: Fits when teams need quick, offset-accurate hex patching and verification on single files.
Hex Fiend
developer toolA macOS hex editor designed for fast editing of very large files.
Synchronized editing across hex, ASCII, and byte offset context with accurate undo for iterative patching.
Hex Fiend opens binary files and renders editable hex with synchronized ASCII and byte offsets. It supports byte-level selection, replacement, and patching workflows with speed on large files.
A dedicated undo history tracks changes at the view layer and helps manage iterative edits. Exporting hexdumps and copying selected regions fits verification and handoff workflows.
- +View stays synchronized across hex, ASCII, and offset readouts during edits
- +High-performance editing for large binaries keeps cursor moves responsive
- +Selection-based replace supports precise byte-range patching
- +Undo history tracks edit operations to reduce rollback friction
- –No guided schema mapping for complex file formats beyond raw byte inspection
- –Automation and API surface are not positioned for programmatic batch changes
- –Disassembly and structured decoding workflows are not a primary focus
- –Advanced governance features like RBAC and audit logging are absent
Best for: Fits when manual binary patching, hexdump export, and precise byte edits matter in desktop workflows.
Hex Editor Neo
developer toolA Windows hex editor with binary comparison, data inspection, and file-editing tools.
Integrated CRC calculation and validation to verify patch impact without leaving the editor.
Hex Editor Neo is a desktop hex editor focused on byte-level editing, structured file inspection, and fast binary search. Its core workflow centers on viewing and modifying bytes at explicit offsets, validating changes through built-in checks like CRC, and patching binaries with targeted replacements.
Hex Editor Neo also includes supporting views that help interpret data as text and numeric types, which reduces the need for external converters. For teams that must repeatedly edit firmware, executables, or packet payloads, it is oriented around repeatable find-and-replace patterns rather than project-based automation.
- +Byte patching workflow stays anchored to byte offsets for precise edits
- +Search-and-replace supports targeted byte patterns across large binaries
- +CRC calculation and validation assist quick integrity checks after changes
- +Multiple interpretation panes reduce friction when mapping bytes to meaning
- –Automation and API surface are limited for scripted bulk operations
- –Binary-to-text interpretation can require manual cleanup for encoding edge cases
- –Large file handling depends on local resources without a documented streaming mode
- –Complex transformations still require external tooling and repeat manual steps
Best for: Fits when analysts or reverse engineers need precise binary patching with repeatable searches for individual files.
WinHex
enterpriseA Windows hex editor with disk editing, data recovery, forensic analysis, and binary inspection features.
Evidence-focused hex editing with offset-first navigation and undo-backed binary patching across disk images.
WinHex from x-ways.net targets byte-level forensic work with a workflow centered on hex editing, disk-image handling, and evidence-safe operations. It supports advanced searching and comparison across large files and raw images, plus structured views that map file bytes to readable representations.
Editing workflows include controlled binary patching with undo history and careful navigation by offsets. Built around low-level analysis tools like endianness handling and header-oriented inspection, WinHex fits investigations that require repeatable byte edits.
- +Strong raw image and file hex workflows for byte-level investigation tasks
- +High-performance search and compare across large artifacts in one interface
- +Reliable offset-driven navigation that supports fast forensic review loops
- +Undoable binary patching workflow designed for iterative edits
- –Steeper learning curve than general-purpose hex editors
- –Automation and API surface are limited compared with scriptable toolchains
- –Some advanced workflows rely on specialist knowledge of binary formats
- –UI density can slow down first-time navigation for newcomers
Best for: Fits when analysts need repeatable byte editing and evidence-oriented review of disks or binaries.
Binary Ninja
API-firstA reverse-engineering platform with disassembly, decompilation, binary views, and byte-level inspection.
Disassembly and decompiler cross-navigation stays synchronized with byte offsets in the hex view.
Binary Ninja is a commercial hex editor and reverse engineering environment that merges byte-level viewing with an analysis engine. It supports disassembly and decompiler views that stay linked to the hex view through navigation across offsets, symbols, and highlighted ranges.
Binary Ninja also provides scripting and a documented plugin interface to automate tasks like format parsing, custom views, and repeated patch workflows. Extensions can persist analysis artifacts so the same binary can be iterated on without redoing manual steps.
- +Offset-linked hex, disassembly, and decompiler navigation for faster triage
- +Extensible plugin and scripting interface for custom analysis and automation
- +Built-in patching workflow that tracks modifications at byte ranges
- +Supports complex binaries with structured type and signature management
- –Tuning analysis results can require significant workflow discipline
- –Some byte-level editing workflows feel slower than focused hex tools
- –Automation depends on scripting knowledge and plugin development time
- –Large projects can slow down when many views stay open
Best for: Fits when teams need repeated byte-level edits tied to disassembly-linked analysis workflows.
Synalyze It!
vertical specialistA macOS hex editor and binary analysis tool with grammar-based structure recognition.
Persistent offset-first navigation that keeps context during hex inspection, search, and binary patch preparation.
Synalyze It! renders hex dumps with byte-level navigation and analysis to support inspection, comparison, and guided editing workflows. It adds binary-specific affordances such as structured views for common file sections and targeted searches across bytes and interpreted text.
Synalyze It! also focuses on reproducible analysis by exporting hexdump outputs and preserving context like offsets during review and patch preparation. Built for hands-on binary work, it emphasizes speed through dense views rather than abstract dashboards.
- +Byte offset navigation stays visible while inspecting and editing.
- +Exportable hexdump output preserves review context for handoff.
- +Search across raw bytes and text interpretation reduces manual scanning.
- +Multiple representations help validate edits without leaving the view.
- –Workflow depth depends on manual operator decisions during patching.
- –Large files can feel slower due to UI-heavy analysis views.
Best for: Fits when teams need fast hex inspection, byte searches, and exportable review artifacts for binary fixes.
Hopper
vertical specialistA macOS and Linux reverse-engineering tool with disassembly, decompilation, and hexadecimal views.
Integrated patch workflow that ties edited byte ranges to updated disassembly context inside one project view.
Hopper targets engineers who need to inspect, understand, and patch macOS binaries with a UI that maps raw bytes to disassembly and runtime-like context. Core capabilities include browsing executable structure, tracking imports and symbols, and editing bytes with undoable workflows.
It supports analysis across common macOS formats and can compare regions quickly during debugging-style investigations. Automation is limited, but the app’s export and annotation paths support repeatable review of byte ranges.
- +Tight byte-to-disassembly navigation for fast inspection loops
- +Strong executable structure awareness for macOS binaries
- +Useful search and replace of byte ranges with clear scoping
- +Exportable views help share findings across reviews
- –Automation and API surface are minimal compared with automation-first tools
- –Workflow stays mostly local to Hopper projects, limiting team reuse
- –Some advanced patching steps need careful manual verification
- –Fewer integration paths for CI workflows than code-adjacent tooling
Best for: Fits when macOS reverse engineers need interactive byte inspection, analysis, and careful binary patching.
Conclusion
After evaluating 10 technology digital media, Hexinator 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 hexa software
Hexa software work for byte-level inspection and patching using offset-accurate hex views tied to actionable verification steps. This guide covers Hexinator, MadEdit, HexEd.it, HxD, Hex Fiend, Hex Editor Neo, WinHex, Binary Ninja, Synalyze It!, and Hopper.
The standout workflow differences show up in how each tool validates edits, how tightly it connects byte offsets to other views like ASCII, and how much automation or API support exists for repeatable changes. Hexinator ranks highest for integrated CRC validation tied directly to edited bytes and for search-and-replace across binary content.
Hex editor and binary patching software for hex dumps, byte offsets, and verification workflows
Hexa software provides interfaces for editing and analyzing binary files at the byte offset level, including hex and ASCII interpretation for confirming byte-level intent. These tools support workflows like pattern search, search-and-replace bytes, and exporting hexdump output for review-ready handoffs.
Some editors focus on interactive verification tightly coupled to edits, such as Hexinator with integrated CRC validation and checksum calculation tied to the edited bytes. Other tools, like MadEdit, prioritize synchronized hex plus ASCII views with offset-accurate navigation for fast byte-level root-cause analysis without requiring automation dependencies.
Hexa editor capabilities that determine verification quality and repeatability
A hexa editor becomes production-worthy when byte edits are tied to verification steps like CRC validation or checksum calculation that can be re-run after patch changes. Tools that keep verification anchored to edited byte ranges reduce the gap between what gets changed and what gets validated.
Repeatability depends on search-and-replace across raw bytes, plus navigation that stays aligned across hex and ASCII or across hex and disassembly-linked views. Editors with synchronized views and offset-first navigation shorten root-cause loops, while editors with limited automation keep teams stuck in manual workflows for batch patching.
Edit verification tied to edited bytes
Hexinator and Hex Editor Neo compute and validate CRC or checksums directly to support patch verification without leaving the editor. Hexinator additionally ties integrated checksum and CRC validation directly to the edited bytes to reduce verification gaps.
Synchronized hex with ASCII for byte-level intent
MadEdit keeps hex and ASCII views synchronized with offset-accurate navigation for byte-level root-cause analysis. Hex Fiend also synchronizes hex, ASCII, and byte offset context so edited cursor positions remain readable during iterative patching.
Offset-accurate patch navigation and stable editing workflow
HxD and Hexed.it both emphasize offset-driven hex navigation so byte placement can be confirmed by position, not by guesswork. HxD adds integrated byte comparison to make change verification faster than re-inspecting dumps.
Binary patch workflow tied to structured views
Hopper connects edited byte ranges to updated disassembly context inside one project view for macOS binaries. Binary Ninja keeps disassembly and decompiler cross-navigation synchronized with byte offsets in the hex view.
Byte pattern search and raw-byte search-and-replace
Hexinator and HxD support search-and-replace bytes against binary content for repeatable modifications. Hex Fiend complements this with high-performance editing for large binaries so cursor moves remain responsive during pattern-driven edits.
Evidence-oriented workflows on disk images
WinHex is built around raw image and file hex workflows for byte-level investigation tasks with undo-backed binary patching. It pairs offset-first navigation and compare-style inspection to keep evidence review tied to specific offsets.
Choosing the right hexa editor based on verification depth and automation needs
Start with how patch verification must happen after each edit, because several tools differ sharply in whether verification is integrated into the editing loop. Hexinator and Hex Editor Neo surface CRC validation inside the editor, while other tools rely more on manual integrity checks.
Decide whether checksum or CRC validation must be integrated into editing
If each patch needs an immediate CRC or checksum result tied to the edited bytes, Hexinator is the clearest fit because its CRC validation and checksum calculation connect directly to what changed. If CRC validation is the priority but batch automation matters less, Hex Editor Neo also keeps CRC calculation and validation in the same byte patch workflow.
Choose synchronized editing views based on how hex intent is interpreted
If intent verification depends on readable ASCII alongside hex, MadEdit and Hex Fiend keep hex and ASCII views synchronized with offset-accurate navigation. If byte-level placement must be confirmed quickly without heavy analysis views, HxD and Hexed.it prioritize offset-driven hex navigation with search and replace across raw bytes.
Select the workflow shape for repeatable patch application versus manual iteration
If patches must be applied across many files with a repeatable process, prioritize tools where automation is not an afterthought, since Hexinator’s standout value is interactive CRC validation rather than a developer-first automation surface. If the workflow stays mostly interactive per artifact, Hexinator, HxD, and Hex Fiend focus on offset navigation and search-and-replace for fast patch cycles.
Map byte edits to analysis context only when disassembly linkage is required
If patching must stay tied to disassembly or executable context, Hopper and Binary Ninja keep byte edits connected to disassembly-linked views. If patching is mostly byte offsets and patterns without disassembly-first requirements, Hexinator, MadEdit, and HxD keep the workflow centered on hex and verification.
Set expectations for shared environments and governance controls
For shared environments where RBAC and audit-log controls matter, MadEdit’s lack of built-in RBAC or audit-log controls makes it a weaker match. For solo or small-team interactive work where governance is handled outside the editor, most offset-focused tools can stay viable because they concentrate on synchronized editing and verification mechanics.
Who benefits from these hexa editor capabilities
Hexa software fits teams that need byte-level control over edits and fast verification loops that prevent mismatched intent. The best audience fit depends on whether verification must be integrated and whether patching requires analysis context beyond hex and ASCII.
Reverse engineers patching executables with byte-to-disassembly iteration
Binary Ninja keeps disassembly and decompiler navigation synchronized with byte offsets in the hex view. Hopper ties edited byte ranges to updated disassembly context inside one project view for macOS binaries.
Security analysts working with disk images and evidence-style comparisons
WinHex supports evidence-oriented workflows across disk images with strong raw image and file hex workflows and high-performance search and compare across large artifacts. Its undo-backed binary patching supports repeated review of what changed at specific offsets.
Engineers who validate patches using CRC or checksum results per edit
Hexinator integrates CRC validation and checksum calculation tied to the edited bytes so verification can be rerun immediately after patch changes. Hex Editor Neo also integrates CRC calculation and validation while staying centered on byte-offset anchored patching.
Analysts doing frequent byte root-cause work with hex plus human-readable ASCII
MadEdit synchronizes hex and ASCII with offset-accurate navigation for quick root-cause analysis during small patches. Hex Fiend keeps synchronized hex, ASCII, and offset context with accurate undo to support iterative byte editing.
Common hexa software pitfalls that cause failed patches or slow workflows
Several failure modes repeat when byte patching tools are chosen without matching verification depth and workflow integration. Most problems come from treating verification as a separate task or expecting batch automation from editors that emphasize interactive patching.
Choosing an editor without integrated CRC or checksum validation for workflows that require repeatable verification
Hexinator and Hex Editor Neo keep CRC calculation and validation inside the patch workflow so each edit can be verified against byte-linked integrity checks. Manual validation outside the editor increases the risk of verifying the wrong byte range after multiple edits.
Assuming disassembly-linked context exists when the editor is primarily a hex and ASCII patch tool
Hopper and Binary Ninja connect edited bytes to disassembly context, which supports patch loops tied to analysis views. MadEdit and HxD prioritize synchronized hex and ASCII or offset-centric editing, so disassembly linkage is not the core workflow mechanism.
Overestimating automation and API needs for batch patching
Hexinator and other interactive desktop-focused editors limit automation and API surface relative to developer tools, which can force manual handling of files at scale. Hexinator’s strength is integrated CRC verification and interactive search-and-replace, so batch throughput requires workflow design outside the editor.
Relying on offset navigation without validating how edits map across views
MadEdit and Hex Fiend synchronize hex with ASCII and offset readouts so edited intent stays consistent across views. HxD and HexEd.it emphasize offset-centric navigation and raw-byte search and replace, which can still work well if view synchronization requirements are low.
How We Selected and Ranked These Tools
We evaluated Hexinator, MadEdit, HexEd.it, HxD, Hex Fiend, Hex Editor Neo, WinHex, Binary Ninja, Synalyze It!, And Hopper using feature coverage, ease of day-to-day patching, and value for interactive binary edit workflows. Features accounted for 40% of the ranking, with CRC validation tied to edited bytes and byte-offset navigation across hex and ASCII or analysis views carrying major weight. Ease accounted for 30% by measuring how directly the workflow supports offset-accurate editing and verification steps during iterative patching.
Value accounted for 30% by balancing integrated verification, search-and-replace across binary content, and workflow constraints against the need for automation and an API surface. Hexinator separated itself by integrating CRC validation and checksum calculation directly tied to the edited bytes alongside fast byte offset navigation and search-and-replace for verification-aligned patching.
Frequently Asked Questions About hexa software
How do Hexinator and MadEdit handle byte-offset navigation and synchronized interpretations during patching?
Which tool is best for exporting hexdump artifacts with preserved byte context for handoffs, and what changes between exports?
When a binary format check depends on CRC validation, how do Hex Editor Neo and Hexinator compare in workflow integration?
What breaks when a team tries to use a hex editor as a forensic disk tool, and how does WinHex behave differently?
How does Binary Ninja keep hex edits aligned with disassembly and analysis state compared with desktop-only hex editors like HxD?
Which workflow is better for quick browser-based hex inspection of local files: HexEd.it or a desktop editor like Hex Fiend?
Which tool supports byte comparison workflows that reduce re-inspection after edits, and what does the diff cover?
How do search-and-replace byte workflows differ between Hex Editor Neo and HexFiend-style manual editing for repeatable patches?
What security controls and audit capabilities are actually common for hexa tools in the reviewed set, and where do they fall short?
Which macOS-focused option best supports interactive byte inspection tied to disassembly context: Hopper or a Windows-first tool like WinHex?
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→