MSIX Flat Bundle Application Packages: Definition, Creation, Deployment

What are MSIX Flat Bundle Application Packages?

MSIX flat bundle application packages are a modern way to package and deploy applications.

Unlike traditional app bundles, which use a multi-level packaging structure, flat bundles simplify the process by referencing the application package files instead of containing them within the bundle.

This means the app package files can exist outside the bundle, enabling parallel processing.

The result?

Reduced upload time, faster publishing, and quicker development iterations – making the entire packaging process more streamlined and efficient.

Benefits of MSIX Flat Bundle Application Packages

The benefits of using MSIX flat bundle app packages are compelling.

Here’s why they stand out:

• Optimized for enterprise use – they are designed to handle the complexities and scale of large organizations.
• Efficient use of network bandwidth – they optimize network bandwidth by downloading only the necessary data blocks, thanks to the AppxBlockMap.xml file. This means faster installations and updates – something IT teams will appreciate.
• Reduced deployment errors – MSIX flat bundles prevent the duplication of files across apps, reducing the risk of deployment errors and ensuring a clean uninstall process, even when multiple apps share the same files.
• Seamless cross-device performance – enterprises often manage diverse device ecosystems, requiring robust deployment solutions that can manage different configurations seamlessly. Flat bundles ensure consistent performance across various devices, making them a reliable choice for enterprise environments.

What is makeappx.exe?

Makeappx.exe is a command-line tool included in Windows 11 SDK. It is used to create and manage MSIX packages, allowing you to:

• Package applications,
• Create bundles,
• Sign packages for added security.

You can download the Windows 11 SDK from the Microsoft website. Once installed, you’ll find makeappx.exe in the bin directory of the SDK installation path.

How to Create an MSIX Flat Bundle Application Package

Let’s go through a real-world example of creating an MSIX flat bundle app package.

Imagine you’re working on a productivity application that needs to be deployed across your company's devices.

Let’s call it "Sample".

There are two approaches to create a flat bundle:

• Using makeappx.exe
  
• Using the MSIX Packaging Tool from Microsoft or Advanced Installer.

Using makeappx.exe

Before we start, make sure you download the makeappx.exe tool and have it ready.

Let’s assume you have two builds of the Sample app:

1. Sample_x64 for 64-bit

2. Sample_x86 for 32-bit

Before packaging, organize your directory structure like this:

Next, we create individual MSIX packages for each build using makeappx.exe.

Open a command prompt and navigate to the directory where makeappx.exe is located.

Run the following commands:

makeappx.exe pack /d SampleApp\Sample_x64 /p Sample_x64.msix
makeappx.exe pack /d SampleApp\Sample_x86 /p Sample_x86.msix

Copy

This will generate two MSIX packages: Sample_x64.msix and Sample_x86.msix.

MakeAppx.exe requires a valid AppxManifest.xml file in the root of the directory where you're packaging the MSIX.

The AppxManifest.xml file contains metadata about your application, such as its name, version, publisher, capabilities, and more.

Here's a basic example of what the AppxManifest.xml might look like:

<?xml version="1.0" encoding="utf-8"?>
<Package xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
     	xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities"
     	xmlns:desktop="http://schemas.microsoft.com/appx/manifest/desktop">
  <Identity Name="SampleApp" Publisher="YourPublisher" Version="1.0.0.0" />
  <Resources>
	<Resource Language="en-US" />
  </Resources>
  <Applications>
	<Application Id="SampleApp" Executable="Sample.exe" EntryPoint="Main">
  	<uap:VisualElements DisplayName="Sample App" Square120x120Logo="Assets/Square120x120Logo.png" />
	</Application>
  </Applications>
  <Dependencies>
	<Dependency Id="Microsoft.UI.Xaml" MinVersion="2.6.0" />
  </Dependencies>
  <Capabilities>
	<rescap:Capability Name="internetClient" />
  </Capabilities>
</Package>

Copy

Using the MSIX Packaging Tool and Advanced Installer

Both the MSIX Packaging Tool and Advanced Installer offer a user-friendly graphical interface with a wizard-based approach to creating MSIX packages.

These tools are great for developers who prefer a visual tool over command-line operations.

If you’re looking for a step-by-step guide on using the MSIX Packaging Tool, check out the MSIX Packaging Fundamentals eBook or our dedicated tutorial on creating MSIX packages using Advanced Installer.

Did you know?

Advanced Installer simplifies troubleshooting with Live Tracing for MSIX Debugging, providing real-time insights into package behavior. This feature helps quickly identify issues like dependency resolution failures and permission conflicts.

Additionally, the AppCompat page makes it easy to apply fixups for application compatibility, with built-in support for the Package Support Framework (PSF). Users can apply predefined fixups, such as: New File Redirection, New Public HTML File, New DLL Path, PowerShell Scripts

For added flexibility, you can create custom fixups, ensuring a smooth and reliable MSIX deployment.

You can try this feature for free through our 30-day full featured trial.

Once your individual MSIX packages are ready, organize them into a directory structure like this:

Now, create the flat bundle using makeappx.exe:

makeappx.exe bundle /d “C:\FlatBundle” /fb /p “c:\SampleFlatBundle.msixbundle”

Copy

This command tells makeappx.exe to bundle the packages in the FlatBundle directory into a single bundle named SampleFlatBundle.msixbundle.

If we inspect the created msixBundle, we’ll see that it only contains a few files:

• AppxBlockMap.xml
• [Content_Types].xml
• AppxBundleManifest.xml

The AppxBundleManifest.xml file lists the information about the MSIX dependencies, and packages.

If we take a closer look, the Sample_X86.msix is listed for the X86 architecture, and the Sample_X64.msix file is listed for the X64 architecture – exactly as we configured it earlier.

Deploying the Flat Bundle

Deploying your flat bundle is straightforward. You can use PowerShell or enterprise deployment tools like Microsoft Endpoint Manager.

Here’s a quick PowerShell snippet to deploy your flat bundle:

Add-AppxPackage -Path <path to FlatBundle>\SampleFlatBundle.msixbundle

Replace `<path to FlatBundle>` with the actual directory path. This command installs the app on the target device.

Ensure that the resulting flat bundle is placed at the top of the folder structure, as shown earlier.
In our example, the flat bundle SampleFlatBundle.msixBundle must be placed directly into the FlatBundle directory.
During installation, it will automatically locate the proper MSIX package (x86 or x64) based on the system architecture.

Conclusion

MSIX flat bundle application packages are a fantastic solution for enterprise app deployment.

By leveraging MSIX flat bundles, organizations can reduce deployment times, minimize errors, and ensure a consistent user experience across multiple devices.

Tools like makeappx.exe and deployment solutions such as Microsoft Endpoint Manager make it easy to create, manage, and deploy these packages.

Whether you prefer using a command-line approach or a graphical interface like the MSIX Packaging Tool, or Advanced Installer flat bundles simplify the packaging process, making enterprise app deployment smoother and more reliable.