What is the size of a Hello World WinUI 3 program (packed with all dependencies)?

[gautambjain]

Assuming I am installing the Hello World WinUI 3 program on a freshly installed Windows 10 PC, what would be the size of the installer?

This answer will help me to decide whether to go ahead with WinUI 3 or not.

[Balkoth]

It depends on a number of things:

• Is WASDK preinstalled
• Packaged or unpackaged
• WindowsAppSDKSelfContained
• SelfContained
• PublishReadyToRun

But in either case you propably won't like the answer. Naked apps created with the "Blank App, Packaged (WinUI 3 in Desktop)" template have around 100 MB. Yes Megabytes!

[gautambjain]

Thanks :o) What if I am installing on a freshly installed Windows 10 (October 2018 update)? And Unpackaged (because I will be creating my own installer).

[Balkoth]

You have to try for yourself, but surely not smaller.

[gautambjain]

Thanks a lot @Balkoth . At another place I read 100 MB + 100 MB (dependencies). For now I will drop WinUI 3 and go for WPF.

[DarranRowe]

Well, I didn't want to provide information for this because of the type of question it is.
But since there has been an answer, I really want to provide complete information.
First, let's list the components that could be part of an installer.
C++
Visual C++ redistributable.
x86 - 13MiB
x64 - 24MiB
arm64 - 11MiB

Windows App SDK redistributables
Executable redistributable 56.8MiB for each architecture. (But this installs all packages possible for a system.)
.misx packages
x86 - 17.8MiB
x64 - 20.3MiB
arm64 - 18.3MiB

The thing that you learn about these is that you only have to install what you need. You can also not install packages like DDLM, Main and Singleton, but they only save you a few hundred KiB.

So, what are the size of the dependencies streamlining as much as possible?
C++
x86 - 13 + 17.8 = 30.8MiB
x64 - 24 + 20.3 = 44.3MiB
arm64 - 11 + 18.3 = 29.3MiB

If you want a complete redistributable install.

x86 - 13 + 17.8 = 30.8MiB
x64 - 23 + 13 + 20.3 + 17.6 = 73.9MiB
arm64 - 11 + 13 + 18.3 + 17.6 = 59.9MiB

(Add on sizes as needed for complete redistributables if you want.)
This is also not using any tricks for C++ like the hybrid CRT. Oh, and the x64 C++ redistributable being extra bloated is there for a work around on arm64 devices, it contains the arm64 version of the redistributable too.

To show that this is actually true.

.NET Framework

First, the difficulty with the .NET framework Windows App SDK/WinUI3 projects is that they are set as self contained by default. Then there is the issue with the file size of the C#/WinRT SDK Reference package. But setting the project to not be self contained drops the size of the layout down to 33MiB.

But it seems there isn't much more that can be done right now since it requires IL trimming. But, once this has been implemented, I wouldn't be surprised to see the raw C# layout get reduced in size to a couple of MiB.

With this out of the way, the redistributable components for .NET are the Windows App SDK redistributable mentioned above, and the .NET Framework redistributable.

.NET Framework Desktop Redistributable 6.0.8
x86 - 50.2MiB
x64 - 55.2MiB
arm64 - 49.3MiB

So this means the expected redistributable size should be.
x86 - 50.2 + 17.8 = 68MiB.
x64 - 55.2 + 20.3 = 75.5MiB
arm64 = 49.3 + 18.3 = 67.6MiB

But the other thing to remember is that you are not going to provide the installer uncompressed. A half hearted compression of the application's layout (by just creating a .zip file through Explorer) decreases the size to 8.7MiB. Using a more aggressive compression method (LZMA2) reduces that to under 5MiB. So properly processed the compressed .NET installer package can be:

But after seeing this, a blithe response would be, if you only care about size then obviously C++ with WinUI 3 would be the obvious choice. If you really care about size then statically linked C++ using Direct2D would be the best option because you don't have to redistribute anything. But that would be horrible to work with.
But as we know, size isn't the only factor.

[gautambjain]

@DarranRowe Thanks a lot.

But as we know, size isn't the only factor.

Very true. Size isn't the only factor.

Can you tell me what is the "Redistributable" thing (225 MB) on this page (in the last column - Runtime downloads): https://docs.microsoft.com/en-us/windows/apps/windows-app-sdk/downloads ?

We will have to ship and install this too?

[DarranRowe]

@gautambjain That is a package of all of the Windows App SDK redistributables in all forms. So no, you wouldn't ship that as is.
If you look inside the file, you will notice that it contains 3 executables and 12 .msix files. The executables are there for easy single executable installs. They contain all of the files for all supported platforms so just including the x86 version of the .exe would be the easiest option in most cases. Yes, it will install the x64 packages on x64 systems and arm64 packages on arm64 systems.
If you are willing to do the extra work then you can just take the .msix packages as needed. This potentially requires a bit more work with the Main and Singleton packages, but they are small enough so that it doesn't matter too much.

[gautambjain]

Great! Now it is clear. Thanks @DarranRowe

[llothar]

Where is the "Deploy WinUI3 Apps" Book?
I have such a book for all other platforms because it is now required and we have "software deployment engineer" as a job description even outside the devops world.

On windows i still wait for a blog post that takes a deep dive with technical specifications and implementation details.
Documentation is one of the big missing features that makes WinUI3 look unprofessional.

Just imagine the poor soul who never heared about windows programming before and trying to set his/her foot on this territory.
Even producing a simple full deployable HelloWorld (2D printed on a canvas based custom control, not a premade label control) will be too hard.

Hope some Microsoft manager reads my rant. And thanks to DarranRowe for giving a tiny section of the blog post i'm waiting for.

[DarranRowe]

@llothar
The majority of what I used was refined from the official documentation.
It isn't perfect, but I was able to get enough information from it to work quite a few things out.