How to publish an Avalonia or Uno Platform app to the Microsoft Store

What each framework documents

The two frameworks take different paths to Windows. Uno Platform has a Windows App SDK target that uses WinUI 3 directly, plus a cross-platform desktop target. Avalonia draws its own UI on Win32 with a plain net9.0 or net10.0 target and no Windows-specific workload.

Uno's publishing overview lists MSIX and ClickOnce for Windows and marks the Microsoft Store as supported. Avalonia's Parcel docs list MSIX as suited to Microsoft Store distribution. Neither one walks through reserving a name or submitting in Partner Center, so this guide fills that in from Microsoft's docs.

How to publish the first version

1. 1

   Reserve the name

   In Partner Center, click New product, choose MSIX or PWA app and reserve your app's name. Then open Product identity under Product management and copy Package/Identity/Name, Package/Identity/Publisher and PublisherDisplayName. Every route below needs these three values in the package manifest.

   <Identity
     Name="(Package/Identity/Name from Partner Center)"
     Publisher="(Package/Identity/Publisher from Partner Center)"
     Version="1.4.0.0" />
   
   <Properties>
     <PublisherDisplayName>(PublisherDisplayName from Partner Center)</PublisherDisplayName>
   </Properties>

   The values are case-sensitive. The fourth number of the version is reserved for the Store and has to stay 0, the first number can't be 0, and none of them can go above 65535.

2. 2

   Build the package

   Follow the section for your framework below: Uno Platform, Avalonia with Parcel, or packaging it yourself.

3. 3

   Make the first submission

   Start a submission in Partner Center and fill in pricing and availability, properties, age ratings and the Store listing. Upload your .msix, .msixbundle or .msixupload on the Packages page and submit it for certification. A full-trust desktop package declares runFullTrust, a restricted capability, so the Submission options page asks you to explain why the app needs it. Once the app passes, the Store delivers updates to your users from then on.

Uno Platform: the Windows App SDK target

Uno's signed packaged app guide covers the Store. Open the solution in Visual Studio with the netX.0-windows10.0.xxxxx target active, right-click the project and choose Publish, then Associate App with Store. That fills in the identity from Partner Center. Then run msbuild from the folder that holds the app's .csproj, because Uno says building at the solution level isn't supported. Uno also notes that dotnet build doesn't work for this as of Windows App SDK 1.5.

msbuild /r /p:TargetFramework=net10.0-windows10.0.26100 /p:Configuration=Release /p:Platform=x64 `
  /p:GenerateAppxPackageOnBuild=true /p:AppxBundle=Never `
  /p:UapAppxPackageBuildMode=StoreUpload /p:AppxPackageDir="C:/temp/output/"

StoreUpload makes the Store package for Partner Center. Change Platform to x86 or arm64 to build more architectures. Uno says msbuild can't bundle them in one step, so you combine the .msix files with makeappx bundle from the Windows SDK if you want a bundle for the first submission. If your app references class library projects, Uno's guide splits the build into a restore step and a package step.

If you build for the netX.0-desktop target instead, Uno's desktop publishing page doesn't cover MSIX. Publish it with dotnet publish and package the folder as described in packaging it yourself.

Avalonia: Parcel

Parcel is Avalonia's packaging tool, installed as a .NET tool. It has a GUI and a command line, and you sign in with an Avalonia account that holds a license for it. Its setup page says the command line isn't part of the free community license.

dotnet tool install --global AvaloniaUI.Parcel
parcel pack MyApp.parcel -r win-x64 -p msix

Parcel generates the package manifest or patches an .appxmanifest template in your project, and its docs say it doesn't need the Windows SDK, so it runs on macOS and Linux too. Set Publisher to the Package/Identity/Publisher value from Partner Center. Parcel otherwise falls back to your Company or application name. Its Package Name and Version settings are normalized for each platform, so open the AppxManifest.xml inside the finished .msix and check that Name, Publisher and Version match Partner Center and the version ends in 0. Putting an .appxmanifest template with your identity in the project is the more predictable way to get exact values.

Parcel's docs say the Store signs the package you submit, and that you turn off Sign Installer when something else signs the package after Parcel.

Packaging it yourself

When your framework doesn't build an MSIX for you, Microsoft documents two ways to package a desktop app. Neither Avalonia nor Uno documents these for their apps, so test the result on a clean machine before you submit.

• The Windows Application Packaging Project in Visual Studio references your app project and builds an MSIX with Create App Packages. The WPF and Windows Forms guide walks through it step by step, and the same steps apply to any .NET desktop project.
• MakeAppx from the Windows SDK packs a folder into an .msix. Run dotnet publish, copy the output and your logos into a folder, add an AppxManifest.xml based on Microsoft's manual packaging template with your Partner Center identity, and pack it.

dotnet publish -c Release -r win-x64 --self-contained -o staging

# add AppxManifest.xml and the logos to staging, then
MakeAppx pack /d staging /p MyApp_1.4.0.0_x64.msix

The Tauri guide has a complete manifest for a full-trust desktop app packed this way, including the runFullTrust capability.

Do you need a certificate?

Not a trusted one. Microsoft's package requirements say the Store replaces any signature on an MSIX with a Microsoft certificate after certification. A build that signs still needs some certificate. A self-signed one works, and its subject has to match the Publisher in your manifest exactly. Uno's guide creates one from the Packaging tab of Package.appxmanifest in Visual Studio, without a password.

How to publish updates with StoreFast

Once the first version is live, connect your Partner Center account to StoreFast and your app shows up on the dashboard. For each release, raise the version, build one .msix and send it in one of these ways.

• Drop it on your app's page in StoreFast. It reads the package name and version on your computer, translates What's new into every listing language and submits the update.
• Add the StoreFast GitHub Action, legendaryspy/storefast-publish@v1, after your build step. The GitHub Actions guide covers the secrets and the workflow.
• Call the REST API from any other CI system.
• Ask a coding agent connected to the StoreFast MCP server. It shows you the update and waits for your yes before it submits.

For an Uno app, the .msix for StoreFast comes from Uno's sideloading build with bundling off, signed with a self-signed certificate that matches your Publisher. Parcel and MakeAppx already make a single .msix.

msbuild /r /p:TargetFramework=net10.0-windows10.0.26100 /p:Configuration=Release /p:Platform=x64 `
  /p:GenerateAppxPackageOnBuild=true /p:AppxBundle=Never `
  /p:UapAppxPackageBuildMode=Sideloading /p:AppxPackageDir="C:/temp/output/" `
  /p:AppxPackageSigningEnabled=true

- name: Publish to the Microsoft Store
  uses: legendaryspy/storefast-publish@v1
  with:
    api-key: ${{ secrets.STOREFAST_API_KEY }}
    app: 9PJWF4W8V4WG
    package: 'dist/*.msix'

StoreFast doesn't take .msixupload or .msixbundle files yet, and the .msix you send replaces the packages in the last submission. If your first release was a bundle with several architectures, an update through StoreFast ships the one you build. The MSIX update guide covers version rules and the upload errors Partner Center gives.

Building with .NET MAUI or WinUI 3 instead? The MAUI and WinUI guide uses dotnet publish and single-project MSIX.

Who it's for

Questions

Does Avalonia document how to publish to the Microsoft Store?

Not as a step-by-step guide. Avalonia's deployment section has no Windows page. Its packaging tool, Parcel, can make an MSIX and its docs say the Store signs the package you submit, but the docs don't walk through Partner Center. The rest comes from Microsoft's MSIX docs.

Can an Uno Platform app built for the desktop target go to the Store as an MSIX?

Uno's MSIX docs cover the Windows App SDK target, netX.0-windows10.0.xxxxx. Its desktop publishing page, for netX.0-desktop, covers folder, single-file and ClickOnce publishing and doesn't mention MSIX. For the desktop target you package the published folder yourself with a Windows Application Packaging Project or MakeAppx.

Do I need a code signing certificate?

Not a trusted one. Microsoft re-signs MSIX packages with its own certificate after certification, and Parcel's docs say the same. A build that signs still needs some certificate, and a self-signed one works as long as its subject matches the Publisher in your manifest.

Why does the version have to end in 0?

Microsoft reserves the fourth number of the package version for the Store. You leave it at 0, the first number can't be 0, and each number goes up to 65535.

Can StoreFast publish my Avalonia or Uno app?

Yes, from the second release on, as one .msix per update. You make the first submission in Partner Center, then publish updates from the dashboard, the GitHub Action, the API or a coding agent. StoreFast doesn't take .msixupload or .msixbundle files yet.