RPGMapEditor is being built as a browser-based RPG map editor, DnD map maker, and battle map maker powered by Rust, WebAssembly, and WebGL.
The main product will stay web-first.
That matters because tabletop creators should be able to open a browser, create a map, save it, export it, and continue working without installing a heavy desktop tool.
But there is now a clear roadmap direction worth exploring:
Bring RPGMapEditor to Windows as a desktop app without rewriting the editor from scratch.
This is not a pivot away from the web app.
This is a distribution and workflow expansion.
The roadmap direction
The plan is simple:
Web-first RPG map editor
+
Windows desktop app
+
Local file workflows
+
Optional cloud sync
+
Microsoft Store distribution
The desktop version would not replace rpgmapeditor.com.
Instead, it would become another way to use the same editor.
Users who want instant access can use the browser version.
Users who prefer a desktop creative workflow can install the Windows app.
Why a desktop app makes sense
RPG map editors sit between two product categories:
- browser tools that are fast to access
- desktop creative apps that feel permanent and file-based
A browser-based RPG map editor is great for speed.
A desktop RPG map editor is better for users who expect:
- local files
- recent projects
- direct image export
- offline-friendly workflows
- a dedicated app window
- operating system integration
That is the opportunity.
The goal is not to build a second editor.
The goal is to make the existing editor available through a Windows desktop workflow.
Why not rewrite everything natively?
A full native rewrite would be the wrong move.
RPGMapEditor already has a Rust-powered architecture:
- Rust backend
- Rust/WebAssembly editor engine
- WebGL rendering
- browser-based UI
- map persistence
- export workflows
Rebuilding the same editor as a native Windows app would create duplicate work.
Every feature would need to be maintained twice.
That would slow down the product.
The better approach is to reuse the existing editor and package it properly for desktop.
Planned architecture
The intended architecture is:
RPGMapEditor Web App
├── Rust backend
├── authentication
├── cloud saves
├── account system
├── pricing
└── map persistence
RPGMapEditor Editor
├── Rust → WebAssembly engine
├── WebGL renderer
├── editor UI
├── asset workflow
└── export system
RPGMapEditor for Windows
├── desktop shell
├── bundled editor frontend
├── local .rpgmap files
├── image export
├── recent maps
└── optional cloud sync
The key rule:
The desktop app should reuse the existing editor instead of forking the product.
That keeps development focused.
The first Windows version
The first version of RPGMapEditor for Windows should be intentionally small.
The minimum useful feature set:
1. Launch the editor from a desktop app
2. Load the Rust/WASM map engine
3. Render maps correctly
4. Create a new map
5. Open a local .rpgmap file
6. Save a local .rpgmap file
7. Export PNG or WebP images
8. Sign in for optional cloud saves
That is enough for a real first version.
Not perfect.
Not overloaded.
Just useful.
What the desktop app should not become
The Windows version should not become:
- a separate editor
- a full native rewrite
- a disconnected product
- a new pricing experiment
- a month-long packaging distraction
- a reason to delay the web editor
The browser editor remains the core product.
The desktop version is a focused distribution layer.
Why Microsoft Store is interesting
Publishing RPGMapEditor for Windows through the Microsoft Store could create a new discovery surface for users searching for:
- RPG map editor for Windows
- DnD map maker for Windows
- battle map maker desktop app
- tabletop map editor
- fantasy map creator
- VTT map maker
The Microsoft Store will not magically create growth.
But it can help with:
- trust
- installs
- reviews
- Windows discovery
- product credibility
- desktop user acquisition
For an early creative tool, that is worth testing.
Roadmap phase 1: Desktop proof of concept
The first roadmap phase is technical validation.
The desktop app must prove that the existing editor works correctly inside a desktop shell.
Checklist:
- app opens successfully
- WASM loads
- WebGL rendering works
- editor UI works
- maps can be created
- exports work
- login flow does not break
- cloud save flow remains usable
If this fails, the desktop roadmap pauses.
There is no reason to force a desktop release if the core editor experience is unstable.
Roadmap phase 2: Local file workflow
A desktop creative tool needs file handling.
The second phase would add:
- New Map
- Open .rpgmap
- Save .rpgmap
- Save As
- Export PNG
- Export WebP
- Recent Maps
This is the real reason for a desktop app.
Without local files, the app is just a website in a window.
With local files, RPGMapEditor becomes closer to a real creative tool for tabletop creators.
Roadmap phase 3: Microsoft Store packaging
Once the desktop version works, the next step is packaging.
The Store-ready version needs:
- app icon
- app screenshots
- store description
- privacy policy
- support page
- version number
- stable installer
- clean first-run experience
The Microsoft Store listing should be clear, not keyword-stuffed.
A simple positioning line:
RPGMapEditor is a Rust-powered DnD map maker and battle map editor for Windows and the web.
Roadmap phase 4: Product-led conversion
The desktop app should be measured like a product channel.
Important events:
desktop_install
desktop_editor_open
desktop_map_created
desktop_local_save
desktop_export_clicked
desktop_cloud_sync_used
desktop_signup_started
desktop_pricing_clicked
A desktop release only matters if users actually create maps.
The goal is not installs.
The goal is map creation, saving, exporting, returning, and eventually upgrading.
Roadmap phase 5: Desktop plus cloud
The long-term product direction could become:
Browser app for instant access
+
Windows app for local workflows
+
Cloud saves for persistence
+
Premium asset packs for monetization
+
Export workflows for VTT use
That creates a stronger product system.
The web app gives speed.
The desktop app gives permanence.
Cloud sync connects both.
Who this is for
The Windows version would be useful for:
- Dungeon Masters creating DnD maps
- tabletop RPG players preparing encounters
- worldbuilders designing fantasy maps
- VTT users exporting battle maps
- creators who prefer desktop tools
- users who want local map files
The browser version remains the fastest way to start.
The desktop version becomes the better option for longer creative sessions.
Why this roadmap matters
Most mapmaking tools fall into one of two categories:
- heavy desktop software
- lightweight browser tools
RPGMapEditor can sit between both.
The product direction is:
fast like a browser tool, but structured enough to feel like a real creative app.
That is why a Windows roadmap is worth exploring.
Not because every web app needs a desktop version.
Not because desktop automatically means serious.
But because map creation is a workflow where local files, exports, and repeat sessions matter.
Current priority
The immediate priority is still the web editor.
The desktop app should not slow down:
- editor stability
- map creation
- export quality
- save/load reliability
- SEO landing pages
- user onboarding
- pricing validation
The desktop roadmap only makes sense if it supports the main product.
Final roadmap summary
The plan is not to rebuild RPGMapEditor.
The plan is to extend it.
Step 1: Keep the browser editor as the core product
Step 2: Validate a Windows desktop shell
Step 3: Add local .rpgmap save/load
Step 4: Add export workflows
Step 5: Package for Microsoft Store
Step 6: Measure installs, map creation, exports, and retention
Step 7: Decide whether desktop deserves more investment
The test is simple:
Can a Rust-powered browser RPG map editor become a useful Windows desktop mapmaking app without becoming a separate product?
That is the roadmap.
If the desktop version helps more users create, save, export, and return to their maps, it is worth continuing.
If it only creates engineering complexity, it should be paused.
The product goal stays the same:
Build a fast, useful, Rust-powered RPG map editor for people who want to create DnD maps, battle maps, and tabletop worlds.
