GITNUXSOFTWARE REVIEW
Video Games And ConsolesTop 8 Best Virtual Tabletop Software of 2026
Compare virtual tabletop software options for running tabletop games, with editorial notes on features and fit for different groups and campaigns.
How we ranked these tools
Vendors set the topic, but our editors set the inclusion criteria and the evaluation framework before research starts.
AI search agents find sources, extract figures with provenance, and aggregate written reviews. They also transcribe video reviews and podcasts.
Framework: Features 40% · Ease 30% · Value 30%
Gitnux may earn a commission through links on this page — this does not influence rankings. Editorial policy
Foundry Virtual Tabletop is the best overall for campaign groups that want deep customization and direct control over their world because its document-based data model and JavaScript API let modules reshape rules, workflows, and interface behavior. Fantasy Grounds is the better fit for rule-driven GM automation since script-based add-ons extend mechanics inside the tabletop runtime.
Editor’s top 3 picks
Three quick recommendations before you dive into the full comparison below — each one leads on a different dimension.
Foundry Virtual Tabletop
Its document-based data model and JavaScript API let modules reshape rules, workflows, records, and interface behavior.
Best for: Fits when campaign groups want deep customization, persistent worlds, and direct control over hosting and game data.
Fantasy Grounds
Editor pickScript-based add-ons that extend mechanics inside the tabletop runtime, not just visual tooling.
Best for: Fits when a GM team wants rule-integrated automation with add-on extensibility.
Owlbear Rodeo
Editor pickRoom-and-scene organization combines fast browser access with an extension SDK for focused campaign workflows.
Best for: Fits when groups need fast browser-based sessions with flexible maps and optional extensions.
Comparison Table
Foundry Virtual Tabletop
enthusiast VTTSelf-hosted virtual tabletop with deep modding support and a one-time purchase license model.
Its document-based data model and JavaScript API let modules reshape rules, workflows, records, and interface behavior.
Groups can run Foundry on a local machine or hosted server, then connect through browser clients without installing software for players. The document-based data model stores actors, items, scenes, journals, playlists, and compendiums as editable records that modules can modify. Game systems provide rule-specific sheets and automation for major tabletop systems, while built-in scene controls handle vision, walls, grid alignment, and map presentation.
The tradeoff is administrative overhead because hosting, updates, backups, and module compatibility remain the group’s responsibility. Foundry fits long-running campaigns with a dedicated game master who wants custom rules, reusable content libraries, and control over server data.
- +Document-based data model supports detailed content editing and module-driven automation
- +Self-hosting gives administrators direct control over files, backups, and access settings
- +JavaScript API enables custom rules, interfaces, workflows, and integrations
- +Broad game-system coverage includes specialized sheets and compendium content
- –Initial hosting requires network configuration or a separate managed server
- –Module conflicts can appear after core software or game-system updates
- –Advanced automation often requires JavaScript knowledge and manual maintenance
- –Mobile play is less practical than desktop browser use
Long-running campaign groups
Persistent worlds with custom content
Reusable campaign infrastructure
Rules-heavy game masters
Automated character and combat workflows
Less manual bookkeeping
Show 2 more scenarios
Technical home servers
Self-hosted remote sessions
Direct infrastructure control
Administrators can run the application locally or on a server while players connect through browsers.
Module developers
Custom interface and rules extensions
Deeper game customization
The JavaScript API exposes application records and workflows for tailored automation and interface changes.
Best for: Fits when campaign groups want deep customization, persistent worlds, and direct control over hosting and game data.
Fantasy Grounds
licensed content VTTDesktop virtual tabletop with licensed official content from major TTRPG publishers.
Script-based add-ons that extend mechanics inside the tabletop runtime, not just visual tooling.
Fantasy Grounds is a virtual tabletop built around game rule integration and a scripted automation model. Character sheet automation and macro-driven dice rolling support rulesets for tabletop RPGs directly inside the client.
The system supports map import and token placement workflows with GM-controlled vision and encounter pacing. Extensibility is centered on add-ons and script extensions that let tables add mechanics beyond the base app.
- +Rulesets drive character sheet automation and rule-aware dice macros.
- +GM tools for encounters include scene control and handouts distribution.
- +Add-on and script extension ecosystem supports bespoke automation.
- +Local network and host options fit non-cloud tabletop sessions.
- –Setup and rule configuration require discipline to avoid session friction.
- –Browser-based access is limited compared with full desktop hosting workflows.
- –Content import workflows can be slow when assets need cleanup.
- –Advanced automation depends on module authoring quality.
Rules-driven RPG groups
Automate character sheets and dice rolls
Fewer manual stat lookups
Dungeon masters
Control encounter pacing and vision
Smarter scene progression
Show 1 more scenario
Homebrew system authors
Extend mechanics via script add-ons
Custom rules in-session
Add or modify tabletop rules through add-ons and script extensions that plug into the client workflow.
Best for: Fits when a GM team wants rule-integrated automation with add-on extensibility.
Owlbear Rodeo
lightweight VTTLightweight browser-based virtual tabletop focused on fast map sharing and token movement.
Room-and-scene organization combines fast browser access with an extension SDK for focused campaign workflows.
Owlbear Rodeo organizes each game around rooms that contain scenes, assets, notes, and participant access. Game masters can upload maps, place tokens, draw annotations, reveal fog of war, and switch scenes during play without rebuilding the session. The extension SDK lets developers add focused workflows instead of forcing every campaign into one rules engine.
The interface suits quick online sessions, remote convention games, and groups that already manage character data elsewhere. Native character sheet automation, integrated compendiums, advanced lighting, and detailed audit controls are limited. A game master running a rules-light campaign can prepare a room quickly, while a rules-heavy campaign may need several extensions and external tools.
- +Browser rooms open quickly for players without desktop installation
- +Scene switching supports maps, handouts, and encounter transitions
- +Extension SDK adds initiative, character sheet, dice, and audio workflows
- +Clean controls keep map preparation and live play easy to follow
- –Native character sheet automation is limited
- –Advanced lighting and line-of-sight features require extensions or workarounds
- –Campaign data and rules content remain less centralized than in larger VTTs
Remote tabletop groups
Weekly campaigns across mixed devices
Low-friction session access
Rules-light game masters
Map-based narrative encounters
Faster encounter preparation
Show 1 more scenario
VTT extension developers
Custom tabletop workflow development
Targeted feature extensions
The extension SDK supports focused additions for initiative, character data, dice, audio, and other campaign needs.
Best for: Fits when groups need fast browser-based sessions with flexible maps and optional extensions.
Roll20
mainstream VTTBrowser-based virtual tabletop with integrated character sheets, dice rolling, and marketplace content.
Macro and sheet-driven dice workflows tie character stats to scripted roll outcomes inside a single VTT session.
Roll20’s core tabletop loop centers on scene creation, token placement, and dice resolution driven by macros and character sheets. The shared dice log records rolls for table transparency, while whisper messaging supports private GM and player channels. Dynamic lighting and fog-of-war features support tactical visibility rules through built-in lighting layers and vision blocking behaviors.
- +Character sheet automation reduces repetitive stat lookups mid-session
- +Macro-driven dice workflows support consistent GM adjudication
- +Shared dice log improves transparency during multi-player rolls
- +Dynamic lighting and vision rules reduce manual GM narration
- –Rules automation quality depends on compatible sheet and macro setup
- –High-detail scenes can be harder to maintain across campaign updates
GM running weekly campaigns
Reuse scenes and macros
Faster prep, consistent rulings
Players using character automation
Automated ability and damage rolls
Less table friction
Show 1 more scenario
Groups with tactical visibility rules
Lighting and fog management
More consistent tactics
Vision blocking and lighting layers enforce cover and sightlines through controlled token vision behavior.
Best for: Fits when groups want macro automation and reusable community assets for repeat sessions.
Shard Tabletop
indie VTTBrowser-based virtual tabletop with built-in character sheet engine and adventure authoring tools.
Scene management geared toward quick GM iteration using in-session placement and live token state syncing.
Shard Tabletop provides a browser-first virtual tabletop for running tabletop RPG sessions with shared maps, tokens, and real-time interaction. Core session building focuses on fast scene setup, interactive token control, and GM-led content placement without forcing a mod-first workflow.
- +Quick scene creation for map-first sessions
- +Real-time token and marker updates for shared play
- +Player-facing browser usage reduces client friction
- +GM controls for placing and managing session elements
- –Limited automation depth compared with modding-heavy VTTs
- –Fewer integration and API hooks for custom tooling
- –Character sheet workflows rely more on manual management
- –Advanced lighting and vision workflows feel less granular
RPG game masters
Map-first pickup sessions
Faster session start
Casual campaign groups
Shared tactical encounters
Clearer movement timing
Show 1 more scenario
Teams standardizing tools
Browser-only play
Lower attendance friction
Players can join through a browser client, reducing setup friction across mixed devices.
Best for: Fits when a group wants fast, browser-based sessions with basic automation and minimal setup time.
Tableplop
SMBA simple web-based virtual tabletop for running RPG encounters without complex setup.
GM-centric scene control with fast map and token management for turn-based play in a browser.
Tableplop is a virtual tabletop built around browser play for groups that want shared maps, tokens, and chat without installing a dedicated desktop client. Core session features center on interactive scenes with draggable tokens, configurable visuals, and a structured dice workflow for common tabletop turns.
- +Browser-based sessions reduce friction for players joining mid-campaign
- +Token and map interactions stay simple for fast table flow
- +Dice behavior fits common tabletop turn-taking patterns
- +Scene navigation supports quick GM switching between encounters
- –Limited extensibility compared with VTTs that support deeper automation
- –Scene and combat tooling feels thinner for complex rules workflows
- –Asset import coverage is narrower than full compendium-driven VTTs
- –Fog and vision control are less granular than advanced line-of-sight VTTs
Pickup game hosts
Run sessions without desktop installs
Lower setup overhead
Table teams using maps
Share draggable tokens on scenes
Less map switching
Show 2 more scenarios
Rules-light game tables
Execute structured dice for turns
Faster rolling turns
Follow a consistent dice workflow that supports common tabletop turn actions in the session interface.
Automation-focused GMs
Integrate external workflows via limited extensibility
Simpler workflow automation
Rely on the available configuration surface while avoiding deep scripting requirements seen in larger VTTs.
Best for: Fits when small groups want browser sessions with basic tactical visuals and minimal tooling overhead.
Fari App
SMBA browser-based virtual tabletop focused on accessibility, ease of use, and modern web standards.
Scene-based GM workflow that keeps map state, token placement, and table-facing outputs grouped per session.
Fari App is a virtual tabletop app focused on running map-first sessions with a GM workflow for scenes, tokens, and shared session controls. It supports browser-based play with live multiplayer features and a dice workflow that can show results to the table.
- +Browser-based client supports quick session join without client installs
- +GM scene organization keeps maps and session state in one place
- +Shared dice log reduces disputes during rules-heavy turns
- +Token controls are straightforward for movement and positioning
- –Fewer integration and automation hooks than module-heavy VTTs
- –Limited visibility controls for complex fog rules compared to leaders
- –Asset import workflows require tighter alignment to native formats
- –Permission tiers feel coarse for large groups with mixed roles
Map-first campaign groups
Run scene-based sessions in-browser
Clear scene context
Dungeon masters
Present scenes with GM token workflow
Better control of information
Show 1 more scenario
Remote players
Roll dice with visible results
Reduced rule disputes
Use the dice workflow to display outcomes to players during real-time browser play.
Best for: Fits when small groups need map-led sessions with shared dice and simple GM organization.
Rolisteam
open-source VTTOpen-source desktop virtual tabletop with shared maps, character sheets, and dice rolling.
Rolisteam’s script extension layer lets custom automation and rule handling run inside the VTT workflow.
Rolisteam is a browser-based virtual tabletop focused on running tabletop games with a shared map, tokens, and real-time chat. The client includes core GM workflow tools like scene management, handouts, and dice rolling with a shared results log.
- +Script extensions enable custom automation beyond built-in GM actions
- +Shared dice log keeps player outcomes consistent across the table
- +Scene and handout workflows support repeatable session prep
- +Browser client supports participation without desktop install
- –Automation depth depends on extension availability and configuration discipline
- –Advanced GM tooling like lighting and occlusion is limited versus top VTTs
Long-running RPG campaigns
Manage scenes, handouts, and logs
Fewer after-session questions
Remote table groups
Chat and move tokens on one board
More responsive play
Show 2 more scenarios
Community rules adopters
Add rulesets and automation with modules
Expanded rules coverage
Extend gameplay using script-based extension mechanisms and community modules for rules and content pipelines.
Session organizers
Control player connections and permissions
Lower disruption risk
Manage session-level access and participation through connection and permission controls.
Best for: Fits when a GM wants a browser table with repeatable scenes and custom rules automation.
Conclusion
After evaluating 8 virtual tabletop software, Foundry Virtual Tabletop 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.
Frequently Asked Questions About Virtual Tabletop Software
How do Owlbear Rodeo and Foundry handle room or server state during long campaigns?
Which tools support a usable JavaScript API for automation, and what gets automated in practice?
What breaks if a group expects module compatibility to work the same way across self-hosted and hosted options?
How do token visibility and lighting rules differ between Roll20 and Foundry Virtual Tabletop?
Which VTTs handle identity and access control well for multi-GM groups, and where does RBAC stop short?
How do data migration workflows differ between Foundry’s document model and tools focused on quick scene setup?
When does browser-based play become a requirement instead of an option, and which tools fit that constraint?
How do dice and shared roll transparency features compare across Roll20 and Owlbear Rodeo?
Where does extensibility land for Fantasy Grounds versus Shard Tabletop, and what does that imply for custom rules?
Tools reviewed
Primary sources checked during evaluation.
Referenced in the comparison table and product reviews above.
How to Choose the Right Virtual Tabletop Software
We separate options by how well the session data stays consistent as you play, and how much control you get over it through tabletop workflows. The biggest differentiators usually show up in data import fidelity and permissions handling.
Import quality for maps and assets
Why it matters
Import quality for maps and assets affects how much rework we do before play. If files come in wrong-sized or broken, our first session loses time and momentum.
How to check
In a demo, import a map image and a few asset files (tokens, handouts, or character sheets) that match what we expect to use. Then verify sizing, orientation, and links to items inside the workspace.
Scene and session organization tools
Why it matters
Scene and session organization tools determine how cleanly we handle changes during a campaign. Strong organization reduces confusion when players return or when we switch maps mid-session.
How to check
Start a demo with two scenes, then switch between them while players are viewing. Ask the host to rename, reorder, and restore a prior scene without manual cleanup.
RBAC and player permission controls
Why it matters
RBAC and player permission controls matter when we run mixed groups or multiple facilitators. Clear roles reduce accidental edits and prevent “who can change what” debates.
How to check
In the demo, create at least three roles (view-only, editor, and facilitator) and assign them to test accounts. Then try modifying tokens, handouts, and notes to confirm the rules hold.
Automation via macros and scripting
Why it matters
Automation via macros and scripting saves time when gameplay repeats. It also helps standardize actions so we don’t rely on everyone doing the same manual clicks.
How to check
Ask for a sample workflow that uses automated actions (for example, rolling with rules text, placing prebuilt items, or applying a template). Confirm where it runs, what inputs it needs, and whether it works for other players’ actions.
Audit log for edits and changes
Why it matters
An audit log for edits and changes helps us recover from mistakes during live sessions. It also supports accountability when multiple people have creation rights.
How to check
After making a few changes (moving an asset, updating a setting, or editing a note), open the activity history. Confirm it records who did what, and whether we can locate and revert the change.
Red flags
- Imports break sizing or links, forcing manual fixes each session
- Roles can’t reliably limit who edits shared content
- History shows minimal detail, so mistakes are hard to undo
Fit by situation
- If we frequently bring our own prepared maps and assets, prioritize import quality for maps and assets.
- If our group revisits work from last session often, prioritize scene and session organization tools.
- If we run sessions with multiple hosts or mixed editing rights, prioritize RBAC and player permission controls.
Funding and competing interests
This study was co-funded by several of the vendors assessed in it. No single vendor funded it. Funders could propose the market studied.
They had no role in selecting vendors, setting or weighting criteria, analysing data or drawing conclusions, and they received the same factual-accuracy check as every other vendor assessed.
Market definition, inclusion rules and criteria weights were fixed by an editor before research began and did not change afterwards. Editorial process →
- Review · 2026 · Video Games And ConsolesTabletop Rpg Software
- Review · 2026 · Arts Creative ExpressionTabletop Software
- Review · 2026 · Technology Digital MediaVirtual Room Software
- Service review · 2026 · Communication MediaVirtual Meeting
- Service review · 2026 · Sales & Leadership TrainingVirtual Team Building
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→