How to publish a .NET MAUI or WinUI 3 app to the Microsoft Store

Which file does each build make?

Microsoft describes three kinds of files. An .msix holds your app for one architecture. An .msixbundle holds several .msix files, one per architecture. An .msixupload is for the Store only and holds the packages or a bundle together with an .appxsym symbol file for crash analytics.

Partner Center accepts all of them. Microsoft also notes that single-project MSIX, which WinUI 3 apps use, doesn't make bundles on its own and produces one .msix per build.

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.

2. 2

   Make sure the app is packaged

   A WinUI 3 app made with the WinUI Blank App (Packaged) template already builds an MSIX. For .NET MAUI, Microsoft's command-line guide sets WindowsPackageType to Package in the project file, because some project types, like Blazor Hybrid, don't make an MSIX by default. In Visual Studio, the same switch is Create a Windows MSIX package under Application, then Windows Targets, in the project properties.

3. 3

   Give the manifest your Store identity

   In Visual Studio, right-click the project and choose Publish, then Associate App with the Store. Sign in with your Partner Center account and pick the name you reserved. Visual Studio fills in the identity fields on the Packaging tab of the manifest for you. Microsoft's WinUI guides call the same menu Package and Publish.

   You can also edit the manifest by hand. In a MAUI project it's Platforms\Windows\Package.appxmanifest, and in a WinUI project it's Package.appxmanifest at the top of the project. The values are case-sensitive.

   <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 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.

4. 4

   Create the package

   Right-click the project, choose Publish, then Create App Packages, and pick Microsoft Store with your app's name. Choose the architectures you want, set Generate app bundle to Always and include the public symbol files. Visual Studio writes an .msixupload to the AppPackages folder. On the last page you can run the Windows App Certification Kit, which Microsoft says is deprecated but still useful as a check before you submit.

5. 5

   Make the first submission

   Start a submission in Partner Center, fill in pricing and availability, properties, age ratings and the Store listing, and upload the .msixupload on the Packages page. Then submit it for certification. Microsoft publishes it once it passes, and from then on the Store delivers updates to your users automatically.

How to build an .msix from the command line

For a MAUI app, Microsoft's command-line guide adds two property groups to the project file. The second one works around a Windows App SDK bug when you pass a runtime identifier.

<PropertyGroup Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows' and '$(Configuration)' == 'Release'">
  <WindowsPackageType>Package</WindowsPackageType>
  <AppxPackageSigningEnabled>true</AppxPackageSigningEnabled>
  <PackageCertificateThumbprint>(your certificate's thumbprint)</PackageCertificateThumbprint>
</PropertyGroup>
<PropertyGroup Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'windows' and '$(RuntimeIdentifierOverride)' != ''">
  <RuntimeIdentifier>$(RuntimeIdentifierOverride)</RuntimeIdentifier>
</PropertyGroup>

Then run dotnet publish on the app project, not the solution, from a Developer Command Prompt. Use your own Windows target framework from the project file. From .NET 10, the runtime identifier is win-x64, and .NET 8 and 9 use win10-x64.

dotnet publish -f net10.0-windows10.0.19041.0 -c Release -p:RuntimeIdentifierOverride=win-x64

The signed .msix ends up in bin\Release\net10.0-windows10.0.19041.0\win-x64\AppPackages, in a folder named after your project and version.

For a WinUI 3 app, Microsoft's CI guide uses msbuild. GenerateAppxPackageOnBuild is the property that makes the package. These arguments make one .msix for x64, signed with a .pfx file.

msbuild MyApp.sln /p:Configuration=Release /p:Platform=x64 `
  /p:UapAppxPackageBuildMode=SideloadOnly /p:AppxBundle=Never `
  /p:PackageCertificateKeyFile=MyApp.pfx /p:AppxPackageDir="Packages\" `
  /p:GenerateAppxPackageOnBuild=true

If you want the Store's .msixupload from the command line instead, the same guide sets UapAppxPackageBuildMode=StoreUpload, AppxBundle=Always and AppxBundlePlatforms="x86|x64", and turns signing off with AppxPackageSigningEnabled=false because the Store signs the package.

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, so you don't buy a certificate or hand over a .pfx. The builds above that sign still need some certificate. A self-signed one works, and its subject has to match the Publisher in your manifest exactly.

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.

The AppPackages folder can also hold the Windows App SDK packages your app depends on, so point the action at your app's own .msix. This step copies it to one place first.

- name: Collect the package
  shell: pwsh
  run: |
    New-Item -ItemType Directory -Force dist | Out-Null
    Get-ChildItem MyApp/bin/Release -Recurse -Filter 'MyApp_*_x64.msix' | Copy-Item -Destination dist

- 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 x64 and ARM64, an update through StoreFast ships x64 only. Microsoft says x64 apps still run on ARM64 devices with Windows 11 through emulation, though native ARM64 builds run better.

Coming from Tauri instead? The Tauri guide packages an MSIX by hand with MakeAppx.

Who it's for

Questions

Do I need a code signing certificate to publish a MAUI or WinUI app to the Microsoft Store?

Not a trusted one. Microsoft says MSIX packages for the Store don't have to be signed with a certificate from a trusted authority, and the Store replaces any signature with its own after certification. A self-signed certificate is enough for builds that sign, as long as its subject matches the Publisher in your manifest.

Should I upload the .msixupload or the .msix?

Partner Center takes both, and Microsoft recommends the .msixupload because it carries the symbol file for crash analytics. StoreFast takes one .msix, so build that for updates you publish through StoreFast.

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 Visual Studio still submit to the Store for me?

Not in Visual Studio 2026. Microsoft's packaging guide says the Automate Store submissions option at the end of Create App Packages is no longer supported there.

Can StoreFast publish my MAUI or WinUI 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.