Can CMake or CPack build an MSIX?

Not directly. CPack's generator list has NSIS, WIX, Inno Setup and others but no MSIX or APPX generator. Use CMake to build and install the app into a folder, then pack that folder with MakeAppx from the Windows SDK.

Should I ship vc_redist.x64.exe or the runtime DLLs inside the MSIX?

No. Microsoft says packaged desktop apps can't use the C++ runtime libraries from Visual Studio or the VCRedist, and that an app using the wrong ones can fail when it touches the file system or registry. Declare a PackageDependency on Microsoft.VCLibs.140.00.UWPDesktop instead, and the Store installs it with your app.

What does windeployqt --appx do?

Qt's docs say it creates an AppxManifest.xml for the Windows Store. You still have to put your Partner Center identity values in it and check the rest of the manifest, so many people start from Microsoft's template instead.

Do I need a code signing certificate?

Not for the Store. Microsoft re-signs MSIX packages when they're published. You only need your own certificate to install a packed .msix on a test machine, and you can test without one by registering the unpacked folder.

Can StoreFast publish my Qt or C++ app?

Yes, once the app is in the Store as an MSIX. You make the first submission in Partner Center, then send each new single .msix from the dashboard, the GitHub Action, the API or a coding agent over MCP.

How to publish a Qt or C++ app to the Microsoft Store

Qt and plain C++ toolchains don't make MSIX packages, so you put the built app and its DLLs in a folder, add an AppxManifest.xml and pack it with MakeAppx from the Windows SDK. For a Qt app, windeployqt collects the Qt files. The Visual C++ runtime comes from a Microsoft framework package that you declare in the manifest. You make the first submission in Partner Center, and after that StoreFast can publish each update.

Package your Qt or C++ app as an MSIX with windeployqt, a hand-written manifest and MakeAppx. Microsoft signs and hosts it, and you don't need a code signing certificate.

windeployqt copies the Qt libraries, plugins and QML modules your .exe needs into one folder.
With MSVC builds, leave the VC++ runtime out of the folder and declare Microsoft.VCLibs.140.00.UWPDesktop in the manifest, as Microsoft's docs ask.
The manifest takes three identity values from Partner Center, a version ending in .0 and the runFullTrust capability.
StoreFast publishes every update after the first, one .msix at a time.

If you'd rather keep your existing installer, the Store also takes EXE and MSI apps, with different rules for signing and hosting. The EXE or MSI vs MSIX guide compares the two. This guide covers the MSIX route.

Collect the app and its dependencies

Build a release version of your app, then gather everything it loads into one staging folder. What goes in the folder depends on your toolchain.

Piece	Where it comes from	In the MSIX folder?
Your .exe and your own DLLs	Your build, or cmake --install	Yes
Qt libraries, plugins, QML modules	windeployqt	Yes
Visual C++ runtime (MSVC builds)	The Microsoft.VCLibs framework package	No, declared in the manifest
Third-party DLLs, like OpenSSL	Wherever you get them today	Yes, next to the .exe

For Qt, run windeployqt from the bin folder of the Qt install that built the app. Pass --qmldir if the app uses Qt Quick, so it can find the QML imports. Add --no-compiler-runtime, because by default windeployqt also deploys the compiler runtime, and an MSIX gets the MSVC runtime another way.

cmake --build build --config Release
mkdir staging
copy build\Release\MyApp.exe staging\

C:\Qt\6.8.0\msvc2022_64\bin\windeployqt.exe --release --no-compiler-runtime ^
  --qmldir src\qml staging\MyApp.exe

If you build with CMake and Qt 6.3 or later, qt_generate_deploy_app_script runs windeployqt for you during cmake --install. Its NO_COMPILER_RUNTIME option does the same job as the flag above. CPack has no MSIX generator, so either way the last step is MakeAppx.

qt_generate_deploy_app_script(
    TARGET MyApp
    OUTPUT_SCRIPT deploy_script
    NO_COMPILER_RUNTIME
)
install(TARGETS MyApp RUNTIME DESTINATION .)
install(SCRIPT ${deploy_script})

# then: cmake --install build --config Release --prefix staging

For a C++ app without Qt, copy the .exe and every DLL it loads that isn't part of Windows. dumpbin /dependents MyApp.exe, from a Visual Studio developer prompt, lists the DLLs an .exe imports directly.

How to handle the Visual C++ runtime

Outside the Store, you'd ship vc_redist.x64.exe, and Qt's deployment docs assume an installer that includes it. An MSIX doesn't run installers. Microsoft's C++ runtime packages for Desktop Bridge page says packaged desktop apps can't use the runtime libraries from Visual Studio or the VCRedist, and that an app using the wrong ones might fail when it tries to reach the file system or the registry.

Instead, add a PackageDependency on Microsoft.VCLibs.140.00.UWPDesktop to the manifest, shown in the next step. Microsoft distributes and updates this framework package through the Store, and Windows installs it alongside your app. To test on your own machine, install the copy that comes with Visual Studio's Universal Windows Platform workload, found under ExtensionSDKs\Microsoft.VCLibs.Desktop\14.0 in the Windows Kits folder, with Add-AppxPackage.

How to package and submit the app

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.

Write AppxManifest.xml

Put an AppxManifest.xml in the root of the staging folder and your logos in an images folder. This one is based on Microsoft's manual packaging template, with the VCLibs dependency added.

<?xml version="1.0" encoding="utf-8"?>
<Package
  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
  xmlns:uap10="http://schemas.microsoft.com/appx/manifest/uap/windows10/10"
  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities">
  <Identity Name="(Package/Identity/Name from Partner Center)"
            Publisher="(Package/Identity/Publisher from Partner Center)"
            Version="2.1.0.0" ProcessorArchitecture="x64" />
  <Properties>
    <DisplayName>My App</DisplayName>
    <PublisherDisplayName>(PublisherDisplayName from Partner Center)</PublisherDisplayName>
    <Logo>images\StoreLogo.png</Logo>
  </Properties>
  <Resources>
    <Resource Language="en-us" />
  </Resources>
  <Dependencies>
    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
    <PackageDependency Name="Microsoft.VCLibs.140.00.UWPDesktop" MinVersion="14.0.24217.0"
      Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US" />
  </Dependencies>
  <Capabilities>
    <rescap:Capability Name="runFullTrust" />
  </Capabilities>
  <Applications>
    <Application Id="MyApp" Executable="MyApp.exe"
      uap10:RuntimeBehavior="packagedClassicApp" uap10:TrustLevel="mediumIL">
      <uap:VisualElements DisplayName="My App" Description="My App"
        Square150x150Logo="images\Square150x150Logo.png"
        Square44x44Logo="images\Square44x44Logo.png" BackgroundColor="#464646" />
    </Application>
  </Applications>
</Package>

The three identity values must match Product identity exactly, including case. The package identity guide covers the errors you get when they don't.
The version has four parts and the last one must be 0, because the Store reserves it. Raise one of the first three for every update.
A Win32 app runs with full trust, so it declares the runFullTrust restricted capability. The uap10 attributes need Windows 10 version 2004 (build 19041) or later. For older versions, Microsoft's template uses EntryPoint="Windows.FullTrustApplication" instead.
Set ProcessorArchitecture to match your build, like x64 or arm64.

3
Pack and test it
Register the folder to try the app before you pack it. Then run MakeAppx, which comes with the Windows SDK, and check the package with the Windows App Certification Kit.
```
# try it from the folder, before packing
Add-AppxPackage -Register staging\AppxManifest.xml

MakeAppx pack /d staging /p MyApp_2.1.0.0_x64.msix

# from an admin prompt, in the App Certification Kit folder
appcert.exe reset
appcert.exe test -appxpackagepath C:\path\MyApp_2.1.0.0_x64.msix -reportoutputpath C:\path\report.xml
```
If the app starts from the folder but can't find a Qt plugin, like the platform plugin, windeployqt missed something. Rerun it against the .exe in the staging folder.
4
Make the first submission by hand
Microsoft requires the first submission of a new app to go through Partner Center. Fill in pricing and availability, properties, age ratings, the Store listing, and upload the .msix. Microsoft's policies say Win32 products always need a privacy policy, so enter its URL. Because the package declares runFullTrust, the Submission options page asks why the app needs it. Certification can take up to three business days.
5
Publish updates with StoreFast
For each release, rebuild, raise the version, pack a new .msix and send it to StoreFast. It checks the package name and version against your app, translates What's new into every listing language and submits the update for certification.

Ways to send updates

From the dashboard: drop the .msix on your app's page. The publishing docs walk through it.
From GitHub Actions: add legendaryspy/storefast-publish@v1 after the step that runs MakeAppx.
From a script or another CI system: call the REST API with an API key.
From a coding agent like Claude Code, Cursor or Codex: connect it to the MCP server, and it asks for your yes before it submits.

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

StoreFast takes a single .msix per update and doesn't accept .msixbundle or .msixupload files yet. If you ship x64 and arm64 builds in one bundle, keep publishing those from Partner Center for now. The MSIX update guide covers version rules and the upload errors Partner Center gives, and the Tauri guide uses the same manifest and MakeAppx steps if you also ship a Tauri app.

Who it's for

StoreFast is a good fit if

Your Qt or C++ app is in the Store as an MSIX and you ship updates often.
Your listing has several languages and you want What's new in all of them.
You release from GitHub Actions, another CI system or a coding agent.

Look elsewhere if

Your app isn't in the Store yet. Make the first submission in Partner Center.
You list an EXE or MSI installer. StoreFast publishes MSIX packages only for now.
You need several architectures in every update. StoreFast sends one .msix for now.

Questions

Can CMake or CPack build an MSIX?: Not directly. CPack's generator list has NSIS, WIX, Inno Setup and others but no MSIX or APPX generator. Use CMake to build and install the app into a folder, then pack that folder with MakeAppx from the Windows SDK.
Should I ship vc_redist.x64.exe or the runtime DLLs inside the MSIX?: No. Microsoft says packaged desktop apps can't use the C++ runtime libraries from Visual Studio or the VCRedist, and that an app using the wrong ones can fail when it touches the file system or registry. Declare a PackageDependency on Microsoft.VCLibs.140.00.UWPDesktop instead, and the Store installs it with your app.
What does windeployqt --appx do?: Qt's docs say it creates an AppxManifest.xml for the Windows Store. You still have to put your Partner Center identity values in it and check the rest of the manifest, so many people start from Microsoft's template instead.
Do I need a code signing certificate?: Not for the Store. Microsoft re-signs MSIX packages when they're published. You only need your own certificate to install a packed .msix on a test machine, and you can test without one by registering the unpacked folder.
Can StoreFast publish my Qt or C++ app?: Yes, once the app is in the Store as an MSIX. You make the first submission in Partner Center, then send each new single .msix from the dashboard, the GitHub Action, the API or a coding agent over MCP.

Publish your app's next update

Make your first submission in Partner Center, connect it to StoreFast and drop the next .msix on the page. Try it free for 7 days, no card needed.

Start your free trial See how it works

Sources

Facts about Microsoft's tools were checked against these pages on October 5, 2026.