GIS-iPad

Meridian for Windows — Microsoft Store Publishing Guide

How to ship the Tauri-based Meridian Windows app to the Microsoft Store. This app is a Tauri 2 host (windows/src-tauri) linking the shared gis_core crate, rendering a Vite/TypeScript + MapLibre frontend through WebView2. Updated 2026-06-23.

Scope note: the iOS/macOS App Store process is covered separately in app-store-publishing-guide.md. This guide is Windows-only.

1. App identity

	Value	Where it’s set
Product name	Meridian	`windows/src-tauri/tauri.conf.json` → `productName`
App identifier	`com.meridian.gis.windows`	`tauri.conf.json` → `identifier`
Version	`0.1.0` (bump to `1.0.0` for a real release)	`tauri.conf.json` → `version` and `Cargo.toml` → `version`
Bundle target (today)	`nsis` (Win32 installer)	`tauri.conf.json` → `bundle.targets`
Runtime dependency	Microsoft Edge WebView2 runtime	bundled `WebView2Loader.dll` resource
Bundled resources	`gdal/` folder + `WebView2Loader.dll`	`tauri.conf.json` → `bundle.resources`
Window chrome	Custom (decorations off, Mica, transparent)	`tauri.conf.json` → `app.windows`

The installed display name stays Meridian. The Store listing name is set separately in Partner Center — if “Meridian” is taken, reserve “Meridian GIS” there without changing productName.

Store-sized tile assets already exist in windows/src-tauri/icons/ (Square44x44Logo.png, Square150x150Logo.png, Square310x310Logo.png, StoreLogo.png, etc.), so the MSIX manifest asset set is already prepared.

2. Choose a submission route

The Microsoft Store accepts two kinds of submission. Pick one before building.

Route A — MSIX package (recommended)

A packaged MSIX gives clean install/uninstall, Store auto-updates, and the standard Store trust badge. Tauri does not emit MSIX directly (it produces NSIS .exe and optionally WiX .msi), so you wrap the built app into an MSIX using the Windows SDK makeappx/signtool, or the MSIX Packaging Tool (free, from the Store). This is the path most Tauri apps on the Store use.

Trade-off: MSIX runs the app in a lightly virtualized container (filesystem/registry redirection). Verify gdal/ resource loading and .gispad file read/write still resolve correctly under packaging (see §6).

Route B — Unpackaged Win32 (EXE/MSI) listing

The Store now lists unpackaged Win32 apps: you submit the NSIS installer Tauri already produces, or point the listing at a hosted installer URL. Less work, no container quirks, but no Store-managed auto-update — the app must self-update or the user re-downloads. Good for a first listing while you validate MSIX.

Recommendation: start with Route A (MSIX) for a clean Store experience; keep Route B as a fallback if packaging surfaces resource/path issues you can’t resolve before the release date.

3. One-time setup in Partner Center

Create/enroll a Microsoft Partner Center developer account (one-time fee; individual or company). Company accounts need verification — start early, it can take days.
Reserve the app name in Partner Center → Apps and games → New product. Reserving “Meridian” assigns you the Store identity values (Package/Identity Name, Publisher, Publisher display name) you’ll paste into the MSIX manifest. If “Meridian” is unavailable, reserve “Meridian GIS”.
Note the reserved identity from Partner Center → Product management → Product identity:
- Package/Identity Name (e.g. 12345Publisher.Meridian)
- Publisher (e.g. CN=ABCD1234-...)
- Publisher display name
Publish a privacy policy URL. Source text is in privacy-policy.md — host it on any public page (GitHub Pages works). Required for the listing.
Decide pricing/markets (free is simplest for v1) and age rating questionnaire answers.

4. Pre-flight gates (do before building the release)

Bump the version to 1.0.0 in both windows/src-tauri/tauri.conf.json and windows/src-tauri/Cargo.toml. MSIX requires a four-part version (Major.Minor.Build.Revision), e.g. 1.0.0.0, and the last part must be 0 (the Store reserves it). Keep tauri.conf.json at 1.0.0; set the 4-part form only in the MSIX manifest.
WebView2 strategy. WebView2 ships in-box on Windows 11 (Meridian’s target), but confirm the bundled WebView2Loader.dll matches your @tauri-apps/api v2 / webview2 versions. For MSIX you generally rely on the in-box runtime rather than bundling the bootstrapper.
GDAL resources. bundle.resources ships a gdal/ folder. Confirm the app resolves it via the Tauri resource path API at runtime, not a hardcoded relative path — packaging changes the working directory and base path. Test a GDAL-dependent import after packaging.
Smoke test the release build on a clean Windows 11 machine (no dev toolchain): launch, create a project, import (GeoPackage/Shapefile/KML), draw + edit geometry, export GeoJSON, verify Mica window chrome and light/dark themes.
No editor-only IDs in exports — same data-integrity bar as every other platform; spot-check an exported GeoJSON.
Run the Windows UI regression (npm run test:ui in windows/) and confirm it passes against the release frontend bundle.

5. Build the release artifact

From windows/:

# 1. Install/refresh frontend deps
npm install

# 2. Produce the Tauri release build (frontend build runs via beforeBuildCommand)
npm run tauri build

Output lands under windows/src-tauri/target/release/:

the executable Meridian.exe
the NSIS installer under bundle/nsis/ (Route B artifact)

The repo’s GNU toolchain note applies: this machine builds Rust with the GNU toolchain + WinLibs gcc (CC=gcc), not MSVC. Ensure the same environment is active for the release build.

5a. Wrap into MSIX (Route A)

Using the MSIX Packaging Tool (GUI, easiest):

Install “MSIX Packaging Tool” from the Microsoft Store.
Choose Application package → Create package on this computer.
Point it at the NSIS installer Tauri produced (or the unpacked Meridian.exe + resources). Let it monitor the install.
On the package-information screen, paste the exact Identity Name, Publisher, and Publisher display name from Partner Center (§3.3). These must match or the Store rejects the upload.
Set version 1.0.0.0, attach the Square*Logo / StoreLogo assets from windows/src-tauri/icons/, and finish to produce a .msix.

Or scripted with the Windows SDK (makeappx + a hand-authored AppxManifest.xml) if you want this in CI — more control, more setup. For a first release the Packaging Tool is faster.

Signing: for Store submission you do not need your own code-signing certificate — the Store re-signs with the Microsoft Store certificate. (You only need signtool + a cert if you also distribute the MSIX outside the Store.)

6. Validate the package

Run the Windows App Certification Kit (WACK) against the .msix (or the installed app): Start → Windows App Cert Kit. Fix any failures before submitting — the Store runs the same checks.
Install the MSIX locally (Add-AppxPackage for a signed test package, or sideload via Settings → Developer mode) and re-run the §4 smoke test inside the packaged container, paying attention to:
- GDAL import (resource path resolution under MSIX virtualization)
- .gispad project save/open to the user’s chosen folder
- File dialogs (tauri-plugin-dialog) and any HTTP/basemap fetches (tauri-plugin-http)

7. Submit in Partner Center

Partner Center → your reserved app → Packages → upload the .msix (Route A) or the installer/EXE (Route B).
Properties: category — Productivity (or Maps & navigation); declare functionality. This app reads/writes local files and fetches online basemaps over HTTPS.
Age ratings: complete the IARC questionnaire (no objectionable content → expect a low rating).
Store listing: name, description, screenshots (capture the Aero/Mica workspace — map canvas, tool dock, attribute table), feature list, the privacy policy URL from §3.4, and support contact.
Pricing and availability: free, choose markets.
Submit for certification. Microsoft runs automated + manual checks; turnaround is typically a few business days. Address any certification report items and resubmit.

8. Updates

MSIX (Route A): bump the manifest version (e.g. 1.0.1.0), rebuild + repackage, upload a new submission. Store delivers the update automatically to installed users.
Win32 (Route B): ship a new installer and create a new submission (or update the hosted installer); users update via your own mechanism, not the Store.

9. Quick reference