GITNUXSOFTWARE ADVICE
Video Games And ConsolesTop 10 Best Card Game Maker Software of 2026
Ranked roundup of top card game maker software for building card games, with tools like Card Game Arena, Screentop, and Magic Set Editor, plus tradeoffs.
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
Card Game Arena is the best pick if you want to ship a playable digital card game prototype with multiplayer validation, while Screentop suits small teams needing a visual, rule-consistent builder for playtesting and exports, and if you’re on a tight budget Summer Engine can generate deckbuilder projects compatible with Godot 4.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Card Game Arena
Hosted multiplayer gameplay execution that keeps author-authored rules aligned with synchronized match state.
Built for fits when shipping a playable digital card game prototype with multiplayer validation..
Screentop
Editor pickDeck validation rules run against assembled decks to prevent illegal card combinations before playtests.
Built for fits when small teams need a visual card builder with rule-consistent playtesting and exports..
Magic Set Editor
Editor pickCard set and card layout authoring with template-driven text formatting for consistent print exports.
Built for fits when teams need a structured card database and print-ready layouts before implementing gameplay in Unity, Unreal, or Godot..
Related reading
Comparison Table
Card Game Arena
vertical specialistSteam-based platform for creating, publishing, and playing digital card games with competitive multiplayer.
Hosted multiplayer gameplay execution that keeps author-authored rules aligned with synchronized match state.
Card Game Arena is the most practical choice when the goal is to test gameplay end-to-end in a multiplayer environment, because gameplay runs in the platform’s hosted client instead of a separate prototype runtime. Card assets, card properties, and rules logic are exercised through real matches, so deck building and turn-based outcomes are validated against synchronization constraints. The workflow pairs authoring with operational publishing inside the same ecosystem, which simplifies the loop from change to opponent feedback.
A tradeoff is that the platform constrains deployment formats to its client model, so projects that need custom Unity or WebGL pipelines or deep engine-level control will hit integration limits. It fits best when a team wants to validate randomized draw, shuffling behavior, and combat-like resolution pacing using real players without building a full netcode stack.
- +End-to-end multiplayer playtesting validates rules under real synchronization
- +Deck building and match sessions are exercised inside the same client
- +Authoring changes can be tested immediately with opponent-driven feedback
- +Turn sequencing stays consistent because game state sync is native
- –Client constraints limit custom runtime integration with Unity or Unreal
- –Advanced effects need careful workarounds when logic goes beyond defaults
- –Asset pipeline customization is less flexible than engine-native tooling
- –Large content sets require disciplined organization to avoid errors
Indie game designers
Prototype-to-public playtesting for new sets
Faster balance decisions from live play
Card game studios
Validate turn sequencing and ordering
Fewer timing and rules disputes
Show 2 more scenarios
Tabletop-to-digital teams
Port rulebooks into playable rounds
Reduced manual testing overhead
Translate mechanics into a functioning digital rules experience for sessions.
Community playtest organizers
Run recurring matchmaking sessions
Higher throughput playtest collection
Use built-in multiplayer sessions to gather consistent feedback across builds.
Best for: Fits when shipping a playable digital card game prototype with multiplayer validation.
More related reading
Screentop
vertical specialistBrowser platform for building and playing custom tabletop games with cards and interactive components.
Deck validation rules run against assembled decks to prevent illegal card combinations before playtests.
Screentop fits teams that want to author card effects as data attached to templates, then assemble decks with guardrails. A rules engine style resolution model helps keep combat math, resource changes, and status effects consistent between the editor preview and later gameplay. Admin workflows support project-level governance for shared work, with collaboration patterns suited to small groups iterating on sets and expansions.
A key tradeoff is that effect scripting tends to favor the platform’s supported action patterns, which can limit custom mechanic depth when a game needs bespoke edge-case resolution. Screentop works best when the game design can be expressed with the provided effect components and deck constraints, then validated before multiplayer sessions.
- +Visual card template editing keeps stats and effect components in sync
- +Deck validation catches invalid builds during authoring and iteration
- +Turn-based resolution model reduces rule drift between preview and runtime
- +Deterministic effect execution supports repeatable playtesting
- –Deep custom rule edge cases can require workaround mechanics
- –Multiplayer synchronization coverage depends on supported action types
- –Large expansion authoring needs stronger organization and naming discipline
- –Complex randomized draw logic may need careful constraint setup
Indie game designers
Prototype turn-based card combat fast
Fewer invalid playtest runs
Card game studios
Build expansion sets with constraints
Consistent expansion rules
Show 2 more scenarios
Multiplayer-focused QA teams
Reproduce deterministic effect outcomes
Lower repro time
Run repeated test scenarios where card effects resolve consistently across sessions.
Tabletop-to-digital ports
Translate tabletop rules into runtime
Faster rules translation
Map status effects, resources, and combat resolution into the platform’s turn-based execution model.
Best for: Fits when small teams need a visual card builder with rule-consistent playtesting and exports.
Magic Set Editor
vertical specialistTemplate-based card editor for creating custom trading card sets and printable card images.
Card set and card layout authoring with template-driven text formatting for consistent print exports.
Magic Set Editor provides a visual workflow for creating card sets and individual cards with consistent card text formatting, including rules text fields and card layout variants. Card editing centers on entering card metadata and effect text in a way that can be reused across multiple cards in a set. The authoring workflow is geared toward producing print-ready outputs and maintaining coherent set structure across revisions.
A tradeoff is that Magic Set Editor does not provide a rules engine, runtime scripting, or turn-based gameplay simulation for validating interactions. It fits best when the goal is a structured card database and exportable card layouts, not a digital card game engine pipeline. Teams can use it to draft an expansion card list quickly, then move effects and logic into a separate Unity, Unreal, or Godot project for actual playtesting.
- +Card text and layout editing stays consistent across an entire set
- +Set management helps organize expansions and card lists
- +Export-friendly outputs support print-and-play production workflows
- +Reusable templates reduce repeated manual formatting
- –No built-in rules engine to validate card interactions
- –Collaboration and audit trails require external file management
- –Digital runtime preview and gameplay simulation are not part of the toolchain
- –Effect logic still needs a separate implementation for engines
Tabletop designers
Draft an expansion card roster
Printable set draft ready
Indie studios
Create assets before Unity import
Faster card content iteration
Show 2 more scenarios
Rules-focused hobby groups
Standardize card text fields
More consistent card readability
Uses repeated layout patterns to keep wording formats aligned across many custom cards.
Print-and-play publishers
Produce playtest print sheets
Shorter print preparation time
Exports card sheets designed for physical testing with fewer manual layout passes.
Best for: Fits when teams need a structured card database and print-ready layouts before implementing gameplay in Unity, Unreal, or Godot.
Tabletop Creator
vertical specialistDesktop software for creating card and board game artwork with reusable assets and print exports.
Template-driven card definitions that keep card fields, visuals, and rules data consistent across expansions.
Tabletop Creator is a card game maker focused on building tabletop-style digital card experiences with a visual editor workflow. It centers on a card database and template-based card definitions so teams can standardize stats, artwork references, and rule-relevant fields across sets.
The tool’s practical strength is turning card definitions into playable behavior for deck flow, turn sequencing, and card effects without building a custom engine from scratch. Deployments are oriented toward sharing and playtesting in a game runtime suited to tabletop simulations.
- +Card database and template reuse reduce duplicated card setup work
- +Visual workflow helps teams iterate on card stats and text rapidly
- +Deck build and validation flows catch rule issues before playtest sessions
- +Tabletop-focused runtime supports turn-based card game behavior
- –Effect scripting depth can hit limits for highly bespoke mechanics
- –Complex multi-system games require careful design to avoid logic sprawl
- –Multiplayer synchronization tooling is not oriented to competitive netcode patterns
- –Custom UI and UX polish can require extra work outside the core editor
Best for: Fits when small teams need fast visual authoring and repeatable card templates for tabletop-like playtests.
Dextrous
vertical specialistOnline card game design software for creating, testing, and sharing card game prototypes.
Deck validation plus reusable effect templates lets card libraries stay consistent across expansions and scenario variations.
Dextrous is a card game maker that lets teams build turn-based digital card logic through a visual workflow editor. It supports creating card templates with reusable effect definitions and validating deck constraints before playtesting.
Integration work centers on connecting the game flow to your runtime hooks and exporting assets for use in your game build pipeline. Automation focuses on repeatable generation of card content and rules behavior from editor configurations.
- +Visual workflow editor for turn resolution and effect sequencing
- +Reusable effect definitions across card templates
- +Deck constraint validation reduces invalid play states
- +Editor-driven generation keeps card content consistent
- –Deeper game-specific logic still needs runtime integration work
- –Debugging complex effect chains can require careful trace review
- –Multiplayer synchronization is not the center of the editor workflow
- –Asset export coverage depends on specific engine pipeline needs
Best for: Fits when teams need visual workflow automation for card effects and deck validation before wiring into Unity, Unreal, or Godot logic.
Component Studio
vertical specialistBrowser-based software for designing cards, tokens, boards, and other tabletop game components.
Component graph assembly that packages card effects as reusable modules for consistent template-driven expansions.
Component Studio builds card games with a node-based visual editor that links UI, data, and effects into a single flow. Card templates and reusable components support repeatable deck and rules construction without rewriting core logic each time.
A project export pathway targets real engine integration, with assets packaged for Unity, Unreal, or Godot workflows. The main distinction is its component graph approach that turns card behavior into configurable building blocks rather than only scripted one-offs.
- +Node graph ties card UI, data, and effects into one build flow
- +Reusable card components reduce duplicated effect and rule wiring
- +Template-based authoring keeps expansion and variant cards consistent
- +Exports designed for Unity, Unreal, and Godot pipelines
- –Advanced turn rules can become hard to trace in large graphs
- –Multiplayer synchronization support depends on the target engine integration
- –Deck validation depth is limited compared with rule-centric engines
- –Custom effect scripting requires stepping outside the visual layer
Best for: Fits when teams want visual card assembly and reusable components across Unity, Unreal, or Godot exports.
nanDECK
vertical specialistWindows software that generates card layouts from spreadsheets and scripted design instructions.
Deck validation tied to authored card templates to flag invalid deck composition during building and testing.
nanDECK focuses on making card game rules and card behavior editable through a visual workflow tied to concrete in-game outcomes. It supports a card database and card template editor flow that helps teams reuse shared assets across many cards.
The core workflow centers on deck building, rule checks, and playtesting-ready game simulations instead of exporting only static card art. Integration depth is mainly around delivering a working digital rules experience rather than deep external data or multiplayer orchestration controls.
- +Visual rules workflow maps directly to turn-based outcomes
- +Reusable card templates reduce repetitive setup across large sets
- +Deck validation catches invalid compositions during authoring
- +Playtest-friendly simulation supports iteration without heavy tooling
- –Limited evidence of granular API access for external tooling
- –Multiplayer synchronization and lobby controls are not its core strength
- –Complex effect logic can require deeper workflow knowledge
- –Export options for print-ready and asset pipelines are not a standout focus
Best for: Fits when small teams need a visual rules workflow for turn-based card games and fast playtesting iterations.
Summer Engine
vertical specialistAI-powered no-code card game maker that generates playable deckbuilder projects compatible with Godot 4.
Deck validation tied to card templates that flags invalid compositions and rule link gaps before runtime.
Summer Engine is a card game maker built around a visual editor that drives game rules from a structured set of card and component definitions. It focuses on turning card data into executable in-game behavior, so developers can iterate on turn-based logic without rewriting core loops.
Summer Engine also supports deploying card games to web runtimes suitable for playtesting and distribution. The workflow centers on reusable card templates and validation steps that catch common deck and rule mistakes before play.
- +Visual rule assembly shortens iteration on turn resolution and card effects
- +Reusable card templates reduce duplication across expansions
- +Deck validation catches missing cards and invalid deck composition early
- +Web-friendly export supports rapid playtest cycles
- –Card effect logic still needs more structure than fully code-free scripting
- –Multiplayer synchronization tooling is less comprehensive than Unity-based custom builds
- –Advanced matchmaking and lobby workflows require extra engineering effort
- –Large asset sets can require careful organization to keep iteration fast
Best for: Fits when teams need a visual card rules workflow and frequent playtests with predictable deck validation.
Boardio
vertical specialistAI-driven card game design tool with digital playtesting and print-on-demand ordering.
Interaction-first board editing that ties card state changes to the visual layout for faster playtest cycles.
Boardio is a card game maker that focuses on visual board and card interactions rather than code-first scripting. It provides a card template workflow, a rules configuration layer, and project publish controls for turning game logic into a playable client experience. Boardio also supports integration-oriented deployment into game runtimes like WebGL so built games can be tested and iterated outside the editor.
- +Visual setup for card placement and interaction flow
- +Card template workflow reduces repeated setup for new card types
- +Rules configuration fits common turn-based resolution patterns
- +Publish controls support quick iteration for playtesting loops
- –Advanced card effect logic needs structured workarounds
- –Multiplayer synchronization and lobby workflows are not the primary focus
- –Deck building and draw randomness tools are limited in scope
- –Complex combat resolution graphs can become hard to manage
Best for: Fits when teams need a visual editor for turn-based card interactions with quick publish and iterate loops.
Card Game Simulator
vertical specialistCross-platform sandbox for creating, sharing, and playing custom card games with online multiplayer.
Turn-by-turn simulation loop designed for card game playtesting without building a full game client pipeline.
Card Game Simulator is a web-based card game maker focused on getting playable digital prototypes quickly from card definitions and game rules. It supports turn-based card interactions with deck shuffling, card draw flow, and resolution loops tailored to card-centric gameplay.
Card Game Simulator also includes tabletop-style simulation for playtesting mechanics without wiring a full client-server build. The workflow prioritizes rapid iteration over deep engine-level control and custom runtime integration.
- +Fast path from card setup to playable turns
- +Built-in simulation loop reduces manual test harness work
- +Deck draw and shuffle behavior is handled inside the editor workflow
- +Rules iteration supports quick changes during playtesting
- –Limited control over combat resolution and branching edge cases
- –Multiplayer synchronization and lobby workflows are not a primary strength
- –External integration options are narrow for custom clients
- –Complex card effect scripting can become hard to maintain
Best for: Fits when small teams need quick playable card prototypes for tabletop-style iteration and mechanic validation.
Conclusion
After evaluating 10 video games and consoles, Card Game Arena 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 card game maker software
Card game maker software is evaluated here by how consistently it can move from authored cards and decks into repeatable playtest outcomes, especially when multiplayer match state must stay aligned. This guide covers Card Game Arena, Screentop, Magic Set Editor, Tabletop Creator, Dextrous, Component Studio, nanDECK, Summer Engine, Boardio, and Card Game Simulator.
The strongest picks prioritize validation and iteration loops that prevent illegal decks or mismatched rules during testing. Several tools emphasize export-ready card databases and layouts for Unity, Unreal, or Godot integration, while others focus on simulation or hosted execution inside a dedicated client.
Validation depth, playtest loop, and integration surfaces
Card game maker software has to keep authored rules aligned with what playtesting actually executes, because deck errors and mismatched effect logic waste iteration cycles. This guide weights validation and loop consistency more than visual editing alone.
Integration surfaces matter when the target runtime is Unity, Unreal, or Godot, since teams need predictable ways to represent card data, deck composition, and effect sequencing outside the editor. Tools that run hosted multiplayer execution reduce the risk of divergence between authoring-time rules and match-time state.
Hosted match execution with synchronized rule alignment
Card Game Arena validates and runs multiplayer play so authored rules stay consistent with synchronized match state during deck building and match sessions. Screentop focuses on deck validation before playtests, so it does not provide the same end-to-end execution path inside a live multiplayer client.
Deck validation against assembled compositions
Screentop runs deck validation on assembled decks to block illegal card combinations during authoring and iteration. nanDECK ties deck validation to authored card templates to flag invalid deck compositions during building and testing.
Template-driven card database and layout consistency for export
Magic Set Editor uses card set and card layout authoring with template-driven text formatting to keep print exports consistent across a set. Tabletop Creator also relies on template-driven card definitions, but it centers on fast tabletop-like playtests rather than setwide print layout management.
Effect sequencing workflows designed for turn-based logic
Dextrous provides a visual workflow editor for turn resolution and reusable effect definitions across card templates. Boardio shifts the workflow toward interaction-first board editing, which improves iteration on visual state changes but sends deeper effect logic into workaround territory.
Reusable components and graph assembly for card effects
Component Studio packages card effects as reusable modules and uses a component graph assembly flow that ties UI, data, and effects into one build flow. Tabletop Creator provides template reuse for card setup and stats, but its effect scripting depth can hit limits on highly bespoke mechanics.
Simulation loop for playable turn-by-turn testing without a full client
Card Game Simulator runs a turn-by-turn simulation loop to validate mechanics through playable turns without building a full game client pipeline. Card Game Arena shifts the value toward hosted multiplayer gameplay execution, which trades that lightweight simulation path for real match state validation.
Pick a tool by how it validates and where gameplay execution happens
The best fit depends on whether validation happens inside a hosted multiplayer execution loop or as an editor-time check over deck composition and authored templates. The second split is whether the tool is primarily a card database and layout authoring environment or a turn-resolution workflow builder.
After choosing the validation and execution philosophy, teams should verify that the tool’s automation and extensibility surface matches the Unity, Unreal, or Godot pipeline they plan to use. Hosted clients reduce authoring-to-runtime drift, while graph or workflow editors shift more responsibility to runtime integration work.
Decide where rules must be validated: hosted match state or authoring-time deck checks
Choose Card Game Arena if multiplayer rule alignment needs to be validated under real synchronized match state during playtests. Choose Screentop or nanDECK if deck validation is the highest priority and the team accepts that multiplayer synchronization is not the core strength.
Choose the primary workflow: template-first publishing or effect-first turn resolution
Choose Magic Set Editor or Tabletop Creator when consistent card text formatting and layout organization across expansions is the primary bottleneck. Choose Dextrous or Summer Engine when the fastest path is a visual workflow for assembling turn outcomes and card effects into testable logic.
Match the tool’s effect model to the complexity of your mechanics
Choose Dextrous or Component Studio when reusable effect templates and component graphs need to support sequencing across many card types. Choose Boardio only when the visual layout interaction model fits the card state changes, because advanced effect logic often needs structured workarounds.
Plan for engine integration if the tool does not own gameplay runtime
Choose Magic Set Editor when card databases and print-ready layouts must be ready before Unity, Unreal, or Godot gameplay runtime is implemented. Choose Card Game Arena when hosted multiplayer gameplay execution reduces the gap between authored rules and match-time behavior.
Evaluate simulation depth versus edge-case control
Choose Card Game Simulator when fast turn-by-turn playtesting is the immediate need and combat resolution and branching edge cases are secondary. Choose Card Game Arena or the deck-validation-first tools when rule edge cases must be handled closer to real execution rather than through a constrained simulation loop.
Check how reusable templates and validation scale across expansions
Choose Tabletop Creator or nanDECK when expansion set management and repeated card setup across large libraries matter. Choose Screentop or Dextrous when the validation and effect templates must stay consistent during rapid iteration across deck and scenario variations.
Who should use each type of card game maker software
Teams should match the tool to how they test, because the category splits between hosted multiplayer execution and editor-time validation workflows. The right choice depends on whether playtesting needs synchronized match execution or whether mechanics can be validated through deck checks and local turn logic.
The sections below map the strongest tool behaviors to common production roles that build digital card games targeting Unity, Unreal, or Godot.
Teams building a multiplayer digital card game prototype
Card Game Arena supports hosted multiplayer gameplay execution where rules are validated under real synchronized match state. This reduces authoring-to-runtime drift during deck building and match sessions.
Small teams that need deck legality checks during iteration
Screentop provides deck validation against assembled decks to prevent illegal card combinations before playtests. nanDECK offers deck validation tied to authored card templates for fast building and testing.
Publishing-focused teams preparing card sets and print-ready assets
Magic Set Editor keeps card text and card layout consistent across a set using template-driven text formatting for print exports. Tabletop Creator supports template reuse for card fields and visuals during tabletop-like playtests.
Designers who prototype turn resolution through reusable effect logic
Dextrous provides a visual workflow editor for turn resolution and reusable effect templates across card templates. Summer Engine offers a visual rule assembly approach tied to card templates for predictable deck validation in frequent playtests.
Developers integrating card logic into Unity, Unreal, or Godot
Component Studio packages card effects as reusable modules using a component graph assembly that ties card UI, data, and effects into one build flow. Magic Set Editor helps front-load card database and layout work before runtime implementation in Unity, Unreal, or Godot.
Common pitfalls when selecting card game maker software
Most selection mistakes come from picking a visual card editor while assuming it will also solve runtime correctness and multiplayer synchronization. Another frequent failure is choosing a tool with strong card template workflow but insufficient effect depth for bespoke mechanics.
The mistakes below map to what each tool is built to do versus what it leaves to downstream integration or structured workarounds.
Assuming deck validation alone guarantees match-time correctness in multiplayer.
Screentop and nanDECK prevent illegal deck compositions during authoring, but Card Game Arena is the tool centered on validating rules under synchronized match state during hosted multiplayer play.
Choosing a print-layout tool for gameplay rules enforcement.
Magic Set Editor focuses on card set and card layout authoring with template-driven text formatting for print exports and does not include a built-in rules engine for validating card interactions. Gameplay validation should be handled in a separate runtime workflow or rules engine layer.
Overbuilding mechanics that exceed the effect scripting or sequencing depth of the editor workflow.
Tabletop Creator can reach limits for highly bespoke mechanics when effect scripting needs go beyond the supported workflow depth. Boardio improves interaction-first iteration, but advanced card effect logic often needs structured workarounds.
Treating a lightweight simulation loop as a replacement for edge-case control.
Card Game Simulator runs a turn-by-turn simulation loop, but it provides limited control over combat resolution and branching edge cases. Hosted multiplayer execution in Card Game Arena supports broader validation during real match state progression.
Ignoring traceability when effect chains grow across reusable templates and graphs.
Component Studio can make advanced turn rules hard to trace in large graphs, so debugging complex effect chains becomes a workflow constraint. Dextrous helps via a visual workflow editor for effect sequencing, which supports clearer turn-resolution tracing during iteration.
How We Selected and Ranked These Tools
We evaluated Card Game Arena, Screentop, Magic Set Editor, Tabletop Creator, Dextrous, Component Studio, nanDECK, Summer Engine, Boardio, and Card Game Simulator by prioritizing validation and iteration loop mechanics that reduce rule divergence during testing. Features accounted for 40% of the ranking, and tool behaviors like deck validation and hosted multiplayer execution received direct weighting because they control illegal builds and synchronized match state.
Ease of use and value each accounted for 30%, with extra credit for workflow clarity such as visual template editing, visual rule assembly, and reusable effect definitions. Card Game Arena separated itself by combining deck building with hosted multiplayer gameplay execution so author-authored rules are validated under real synchronized match state inside the same client.
Frequently Asked Questions About card game maker software
How does Card Game Arena handle multiplayer state compared with Card Game Simulator when playtesting card effects?
Which tool connects a visual card template workflow to WebGL and mobile-friendly deployment for play sessions?
What breaks if deck validation is skipped when building a turn-based card game in Screentop versus Dextrous?
When do teams choose Magic Set Editor over exporting gameplay into Unity, Unreal, or Godot workflows?
How do deck constraints and turn-based logic differ across Summer Engine and nanDECK during authoring?
What integration approach works best for teams that already have an engine and want to wire card logic via runtime hooks?
How do admin controls and governance requirements show up in Magic Set Editor compared with tools that package reusable components?
What is the tradeoff between template-driven print export workflows and component-graph exports for Unity, Unreal, or Godot?
How does Boardio model card state changes compared with Card Game Arena when iterating on board interactions?
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
Video Games And Consoles alternatives
See side-by-side comparisons of video games and consoles tools and pick the right one for your stack.
Compare video games and consoles tools→