The Death of UWP: A Framework That Was Technically Successful but Commercially Failed; What Should a Modern Operating System Really Provide?

At the beginning of 2023, out of habit, I opened the UWP Mail app to check and send my daily emails. To my disappointment, it was already suggesting that I try the new Mail App.

As I suspected, the new Mail app bundled with Windows is a web wrapper, not a UWP application. This means that since the success of VSCode and Teams, Microsoft has been going further and further down the path of web wrappers. To the point where they are now extending this approach to Outlook.

When Windows 10 was first released, I hoped that one day I would be using a UWP version of Visual Studio. After waiting for years, I ended up using MSEdge, which is an exe, and a web-wrapped Mail app.

UWP, which was meant to be Windows' last major technical revolution, has officially failed. But before I deliver its eulogy, perhaps we can look back on the framework's life. Its ambition at birth, the difficulties it faced, the revolutionary technical changes it brought, the many problems it solved, the new platforms it enabled, and its tragic journey.

UWP is inherently an excellent framework

If I had to sum up UWP in one line, I’d say: successful technology, failed business.

When I bring up UWP with friends around me, their reactions are mostly: What? UWP? Isn’t that garbage? Aren’t there hardly any apps? Isn’t it only for idiots? Doesn’t it crash all the time and lack permissions? Isn’t it that thing from the store where even the download progress bar doesn’t work and you can’t buy anything? Isn’t it the kind of app meant only for the dumb Windows tablets that only suckers buy?

But, from another angle, UWP was also Microsoft’s last real chance to make a great transformation. It unified all devices and platforms, supported GPU passthrough, dynamic DPI, automatic updates, a unified download center, multilingual support, live tiles, more power-efficient background execution, multilingual support, clean installation and uninstallation, better permission control, no viruses, ARM platform support, dependency management, extremely low system requirements… These features make it almost an ideal development framework.

Perhaps that still hasn’t convinced you of UWP’s technical excellence. We need to go further and discuss what Windows platform developers actually need.

Today's Windows Is a Mess

Looking back at Windows, we find that it has become an operating system that accommodates every conceivable oddity.

For example, if you are developing an app for the Windows platform, which technology should you adopt? WinForm? WPF? Electron? Qt? PWA? A proprietary solution? You will find that there is no ideal choice.

For instance, on the Windows platform, where do you think an app should be installed? A standard app might be placed in C:\Program Files. Some apps might reside in C:\Users\You\AppData\Local. Others might be located under C:\Users\You\FastCopy. Some might be found in C:\Ruby. There are even strange applications that ask you to install them on the D:\Starcraft drive...

Another example: on the Windows platform, where do you think an app’s data should be stored? A standard app might store its data in C:\Users\You\AppData\Romaing. However, some apps store data in their own installation directory, such as C:\Program Files(x86)\Steam\Userdata\1837648. Some apps store data in the current directory. Others place it on the desktop. Some store it under C:\Users\You\Documents\Tencent...

Many baffling development approaches and novice code that follows the "if it runs, it's fine" mentality tend to hardcode bizarre paths, causing the file system of a long-used Windows machine to become a chaotic mess.

Windows is inherently a multi-user system. Multiple users may use a single Windows installation simultaneously. Will their data get mixed up? Can applications be shared? You never know how many of your system paths are being cluttered by the numerous applications installed on your computer. Even simply uninstalling an application is unclear in terms of how many locations need to be cleaned up, and whether the uninstallation should apply to all users or just the current user.

Difficulties in Application Development

Developing an application on the Windows platform comes with an extremely low baseline of support, riddled with inconsistencies, and plagued by numerous baffling issues that developers should never have to deal with, yet are ultimately left to solve on their own.

For developers, these recurring problems are consistently a source of confusion. As a result, when building an application, a disproportionate amount of time is often spent addressing these common underlying issues rather than focusing on the business logic itself.

Clearly, a modern framework or operating system should already provide solutions for these issues, such as:

Background Tasks and Resource Scheduling

As is widely known, having too many icons in the notification area of the taskbar in the bottom-right corner of Windows can indicate that too many processes are running, potentially causing the computer to become sluggish.

However, computer performance is often more closely related to the remaining CPU, memory, and disk performance. The operating system itself should be responsible for scheduling foreground applications to enjoy higher-priority computational resources and reasonably downgrading the computational resources of applications that are not frequently used. For example, when using a mobile phone, you do not need to deliberately close an app; the system itself schedules their computational resources so that you never feel any lag.

This is a basic function of modern operating systems, but it is very difficult to achieve in Windows. For instance, Windows is often unsure whether an application minimized to a tray icon can be killed or paused. It could be your Battle.net downloader, your WeChat, or your music player. Killing them might negatively impact the user experience. However, allocating computational resources to them might mean they do not actually need those resources.

In reality, almost any process in Windows can directly consume all available memory, CPU, and disk resources. Developing applications on an operating system that cannot properly handle background tasks relies entirely on each app behaving well. Once the computer becomes sluggish, users may suspect any app or simply complain that "too many are open."

Self-Updating and Package Management

As is well known, few applications today stop their lifecycle immediately after installation. Almost all applications require updates to obtain new features and security patches.

On mobile devices, self-updating is well supported through the App Store or Google Play. On Linux, it can be handled with a simple apt upgrade. However, on Windows, the concept of an application updating itself becomes quite peculiar.

Windows Update handles the system itself and drivers. However, the update mechanisms for specific applications are implemented in highly varied and inconsistent ways.

• Some can be updated via Winget
• Some require manually running commands like npm update -g
• Some are updated through the store
• Some implement A/B updates internally
• Some download the new installer and perform a silent installation
• Some download the new installer and prompt the user to manually overwrite the existing installation
• Some simply pop up a web page for the user to download and install the new version manually
• Some do not support automatic updates at all
• Games often require launchers and gaming platforms to complete updates.
• ...

This results in a situation where, to use a major piece of software, one must download and register for a launcher, such as Adobe Creative Cloud or Steam, and then purchase and update the software before it can be used.

Perhaps we have become accustomed to this model and no longer find it strange, but these approaches clearly share a common logic: we simply want applications to be able to update themselves so that users can access the latest possible versions. Yet, the methods used vary wildly across different scenarios.

I simply want to update all components on my Windows computer to the latest versions, and it is this difficult.

In other words, Windows lacks a reliable tool to manage dependencies and updates for individual applications (and even the operating system itself) (package management).

Localization and Advertising

Localization is not simply translation. Different countries and regions often have distinct legal requirements, languages, date and time formats, and typography conventions. For instance, on most mobile phones, there is only one place to set the language, and this setting directly affects all applications on the device.

However, this becomes significantly more challenging on the Windows platform. Almost every application has its own independent language setting. Even if you change the Windows language, the Office language does not automatically change to match it.

Another example is the need for applications to obtain a unified advertising ID to deliver customized ads to users. Perhaps because this is too difficult on Windows, Windows applications have largely abandoned advertising as a revenue model and instead rely solely on selling their own ancillary services. In contrast, this is so easy on Android that it has become ubiquitous.

For example, developers may need their app to display different content or provide different features in different countries. Traditional Win32 applications still lack this capability, forcing developers to build their own APIs to handle such scenarios.

Permissions

As is widely known, any Windows application can directly take a screenshot of your screen or restart your computer. None of this requires administrator privileges.

An application can directly steal confidential information stored in D:\password.txt, directly access explicit content you have saved in your OneDrive, directly access Chrome cookies in your AppData folder to hijack your accounts, or directly expose an internal network port to the public internet (frpc).

Windows permission control is like this: I only know of two scenarios: either I am an administrator, or I am not. For an application that is not an administrator, its privileges are still absurdly high. An application with administrator privileges can even replace system files to turn your operating system itself into a surveillance tool, or make you see fake websites when accessing important sites, all while displaying a valid green HTTPS certificate.

And when an application does any of the above, it does not even need to notify the user.

A mature application framework should inform users about what permissions an application has, when and where it accessed those permissions, and make it easy for developers to request and manage them. Clearly, Win32 App does almost nothing in this regard.

Virtual Sandbox File System

As an operating system, it should inherently provide a highly convenient platform for developers to build various applications. This includes offering robust background services, push notifications, unified storage, a virtual file system, and effective permission management, while also assisting developers with application updates.

For instance, the binary files that constitute an application should not be directly accessible or understood by the application itself. Applications must not have arbitrary access to the underlying file system. Instead, they should only be granted access to a "virtual" space where they can store their own data. This space must be secure and isolated. Even when different users access the same application, there should be no data contamination between them.

The operating system itself should efficiently schedule these virtual sandboxes. For example, it could pre-load the virtual file systems of frequently accessed applications into a RAM disk, place files for commonly used applications on an NVMe solid-state drive, and store applications that have not been opened in years on the slowest, largest mechanical hard drive. Developers should never need to interact with the specific underlying file system; they should simply always access this fast, large, and secure virtual file system.

Difficulties in Personal Use

Even for developers, who already have to deal with so many issues, Windows still has a surprisingly high barrier to entry. You might think that most people are already using Windows these days. But making Windows user-friendly is far from simple. After all, it’s not hard for many users to end up with a Windows device that is sluggish, unstable, and frequently plagued by viruses and hacker attacks.

An operating system could ideally address these issues, but it seems Windows hasn’t made much effort to handle them properly.

My Computer Should Always Be Fast

As is well known, keeping a Windows PC consistently secure, stable, and fast is a highly challenging task. Even veteran Windows users with decades of experience can inadvertently cause their systems to become sluggish. Users must carefully organize the contents of the C: and D: drives, handle disk partitioning with caution, verify that new software behaves appropriately before installation, and even manage their desktop icons and Start screen layouts.

However, merely spending time on maintenance is not enough. Users are forced to constantly track which applications they have opened and which ones they should close when temporarily unused. This is because they are always mindful of the long-standing Windows adage: “Opening too many programs slows down the computer.”

An excellent operating system should guarantee that, regardless of how you operate it or how many applications you have open, the few you are most likely to use will always respond quickly. When you return to an application, it should naturally restore as closely as possible to the state you left it in. The operating system should be able to predict which applications you are likely to use next and preload them into high-speed cache, while putting applications you are less likely to need temporarily into a dormant state (moving them from high-speed cache to persistent storage).

My computer should always be stable

Considering that Windows itself has already become riddled with unpredictable behavior after so many applications have been installed, and given Microsoft’s equally opaque automatic updates, it is difficult to even guarantee that your computer will boot up successfully after the next restart.

A high-quality operating system should be able to correctly handle dependencies, resolve conflicts during updates, implement version control for each component, support filesystem snapshots and rollbacks, and manage the system as read-only with an A/B partition setup. This ensures that a functional operating system is always available and allows updates to be completed seamlessly without user intervention.

My Computer Should Always Be Safe

Information security on the Windows platform relies even more heavily on experience and verification. Even running a three-line NodeJS script that hasn't been verified could potentially leak your cookies or confidential files in OneDrive, forcing users to manually verify whether everything they intend to run is trustworthy.

This might be feasible for a professional developer, but the majority of Windows users are likely to be your aunt who only uses her computer to search for recipes, or an influencer who only uses their PC for gaming.

Forget about whether technologies like UEFI, TPM, Secure Boot, BitLocker, UAC, and Windows Hello are even correctly enabled; these users often can't even confirm the origin of their operating system. The security landscape on the Windows platform remains one with extremely high potential but equally low floors.

Consider Your Android Phone

Perhaps you may not fully agree with the points above, but when you look at your phone, you'll realize it seems incredibly simple: you haven't had to learn about BitLocker, TPM, or other security concepts to use it safely. You don't constantly worry about closing unused applications, nor do you fear that your phone might fail to boot after being left idle for a short time.

All you know is that when you need something, you simply open Google Play and download the app you require.

These expectations, however, have existed for decades on Windows, yet we see no signs of improvement.

What Do Developers and Users Need?

In summary,

Developers want things to be effortless and low-maintenance. They just want to write their business logic without overthinking. The operating system itself should handle distributing to the right markets, promoting the right ads, loading into the appropriate cache at the right time, opening as fast as possible, and providing power-efficient push notifications and background service mechanisms, all while supporting native automatic updates. Developers can simply access their virtual file system without worry. It is always that fast, that secure, and that spacious. They don't even need to know what it actually is under the hood.

For individual users, they also want things to be effortless and low-maintenance. The operating system suggests apps they might like, and they just need to click install without thinking. They don't need to worry about multiple users; they don't need to worry about permissions; they don't need to worry about language mismatches or policy issues; they don't need to worry about battery drain or background resource usage; they don't need to worry about whether to install on the C drive or D drive; and they certainly don't need to manually update them. They are simply that easy to use—install and go. Even if something breaks, they can reset with one click or restore a specific app to factory settings.

And UWP is clearly meant to be

You may have already noticed: all the issues I mentioned above have been resolved by UWP!

UWP has a robust store that helps you restore previously purchased content and download legitimate applications. Users only need to click through a few steps.

UWP features comprehensive version and dependency management, so you don’t need to repeatedly download duplicate dependencies. In fact, most applications require downloading only a few KB of content to be ready for use.

UWP offers sophisticated storage space management and a virtual file system. Users don’t need to worry about whether an app is installed on the C: drive or in a specific directory; apps are automatically placed in appropriate locations. Additionally, users can see how much space an app and its data occupy and can reset an app at any time.

UWP has seamless automatic updates. I have never manually updated a UWP app. They are always up to date.

UWP provides excellent localization. In your local app store, the apps you download are tailored to your country’s market and language. Moreover, when you travel to another country, you can directly download the version intended for that region.

With UWP, you don’t need to worry about having too many apps open or running in the background. I once tried opening all the installed UWP apps on my computer, and they still ran smoothly and quickly, consuming almost no computational resources. Even after closing them, they could still send me notifications at appropriate times.

UWP has robust permission controls. I never worry about running UWP apps from unknown sources. I know their permissions are confined within a sandbox. They cannot access my files or hardware, modify my DNS settings, execute custom commands, take screenshots of my screen, or read my cookies.

UWP is inherently cross-platform. UWP apps developed for Windows can generally run on Windows Phone or Xbox without code modifications, with nearly identical user experiences and interfaces. Furthermore, almost all UWP apps can be quickly ported to ARM platforms. This should have been a major weapon for Microsoft in competing in the mobile market, offering a last chance to stand on equal footing with Android and iOS.

UWP can correctly use the GPU to render its interfaces. Resizing windows doesn't cause lag but updates in real time. The translucency effects are visually stunning without consuming CPU resources. Menu animations and gestures used to respond swiftly, even when adjusting the DPI, the display remained crisp. On the surface, it looks like a very modern framework.

It seems UWP has solved all the problems mentioned above! Whether for developers or users, it represents the next generation of Windows applications, embodying Microsoft's perfect solution to these long-standing Windows issues. It's easy to develop, distribute, manage, update, and use. Even uninstallation can be completed in 1 second, making it a framework that feels truly futuristic.

Really?

But the reality is... UWP is dead.

The Death of UWP

As I said, UWP is the future; it is perfection; it is the answer.

But reality is that the technically best framework often turns out to be the most commercially unsuccessful. UWP is a prime example: a concept and vision that transcended everything, technically powerful and absolutely perfect, yet an absolute commercial failure—there were hardly any apps, and the few that existed were generally of poor quality.

No matter how good an operating system is, if there are no apps to use, it is still useless. Users don’t care about the system itself; they care whether the system can let them run their favorite games and social media apps.

With UWP, either the software is scarce, or even if you install it, it’s just a web app wrapper with 90% of its features cut.

I once really liked the UWP version of QQ—it was clean, easy to use, didn’t consume much resources or permissions, and supported background push notifications. But it couldn’t log in. I once really liked the UWP version of WeChat—it was also clean and easy to use, but later it lost the ability to send background push messages. I once really liked Halo: Spartan Strike on UWP, but it couldn’t sync game progress across devices anymore. I also once really liked the UWP versions of Zhihu and Bilibili… but later they were no longer maintained...

If the scarcity of apps could be excused as needing time to mature, the scarcity of features is a definite fatal flaw. Eventually, major internet companies completely abandoned this framework and stopped developing desktop UWP apps for Windows. It seems even Microsoft itself abandoned the framework, starting to release web-wrapped Mail and exe-based Edge.

UWP is more like a new-generation prince: trained in all kinds of skills, but born at the wrong time. At its birth, its competitors had already run far ahead. Even though it carried the mission of solving many problems left by the older generation, it was powerless in the competition, suffering from a lack of support—even from its own parents—who paid it no attention, leading to a pitiful fate.

Already Lost the Market

An excellent platform benefits from a growing number of developers joining in, which in turn provides users with more high-quality apps. As the user base expands, developers can also attract a larger audience.

Once a platform achieves success, it creates a mutually beneficial win for both attracting users and developers.

However, failed platforms often struggle because users are unwilling to use them and developers are reluctant to build for them. After Microsoft lost the mobile market, it might still rely on support and subsidies in the short term to lure developers, but regaining that lost influence is not something that can be achieved overnight.

With Microsoft’s retreat from the mobile market, what I observe is more akin to Microsoft giving up its ambition to reclaim the consumer market through UWP. Instead, the approach to consumer products has shifted to a “good enough” attitude. In this environment, hardly any developer is willing to use a framework that “only runs on Windows 10” to develop Windows applications.

In the early days of UWP, both applications and the platform generally suffered from low quality

In its early days, UWP apps were generally of poor quality. I can understand that, to some extent. But even Microsoft’s own UWP apps were mostly underwhelming in terms of functionality.

Take the Microsoft Store, for example: the download progress bars were pure guesswork. They would often stall for ages, only to suddenly jump up to nearly complete.

Or consider Microsoft’s own News app: whether it would even open was a matter of luck. It frequently insisted it had no internet connection, without providing any specific error message.

As for Microsoft’s original UWP-based Edge browser, it would often freeze with a blank white screen, showing no response or progress. Multi-tab browsing frequently crashed. Its so-called high performance could only be replicated in ideal conditions, and in real-world use, it simply couldn’t compete with Chromium-based browsers.

During UWP’s early period, crashes, inexplicable unresponsiveness, and waiting half an hour for an app to open... these became everyday issues. This extremely poor user experience led users to assume: UWP = low-quality app.

One Issue, a Bunch of Solutions

For example, how many ways do you have to install Outlook on Windows?

You can use the UWP version of Mail. You can install Office to access the desktop version of Outlook. You can use the PWA version of Outlook. You can use a web wrapper for the next-generation Mail, and you can even use the Outlook running on the Android subsystem. The key point is that their features are all different?!

When using OneNote on Windows 11, you can still use the classic desktop OneNote, you can use the OneNote PWA, and you can even use a UWP app called OneNote for Windows 10?! And their features are not the same either??

When opening a video in Windows 11... you can use Videos, you can use Photos, you can use Media Player, and you can even use Windows Media Player!?! And their features are not the same either??

The most absurd part is that Microsoft itself seems to lack a unified design style for how to design a UWP app. Even their own apps seem to be split into several different styles.

Developing a UWP Application Is Actually Quite Difficult

Unlike traditional Win32 development, which allows you to dive right in, UWP has a significantly steeper learning curve. Considering that it acts more like an actor on a managed stage, much of the development process requires developers to properly learn how to use this "stage." For instance, UWP cannot directly access the file system, cannot directly access hardware, and cannot directly access processes and commands. As a result, many applications are essentially unusable in UWP.

You will not find a junk file cleaner for UWP, a hard drive diagnostic tool, or a CPU benchmarking tool. You will not find hardware testing utilities for UWP, nor will you find UWP databases, let alone UWP security tools.

• UWP can at most serve as a compressed file manager, but it is not particularly easy to use because it cannot register in the right-click context menu.
• UWP makes it difficult to take screenshots, and you certainly will not find UWP live streaming tools.
• UWP makes it difficult to overlay content on top of another window, so you will not see UWP auxiliary tools.
• UWP makes it difficult to communicate with other processes. You will not find UWP development tools; at most, you will only find code editors.
• UWP makes it difficult to utilize advanced network features. You will not see UWP network tools; at most, you will only find speed testers.

This makes UWP seem more suitable for developing social media applications like Twitter, Instagram, and YouTube. Microsoft has personally demonstrated just how difficult to use UWP social media apps can be. Obviously, these social media companies cannot see any promising future in investing in such a framework...

At this point, individual learning developers, DIY enthusiasts, large enterprises, and developers who need their applications to run on Windows 7... they have almost all abandoned this framework. So who is left?

The Death of UWP

At this point, we can only witness one thing: UWP is dead. And there is no hope for its revival.

I know a Microsoft MVP renowned for his proficiency in UWP development, known as Adi Wang. Perhaps his greatest grievance with Microsoft is the abandonment of UWP. As WinUI migrated away from UWP, UWP seemed like a corpse, with only usable components being salvaged to serve some lingering purpose.

The new development framework: MAUI is being reborn. They have discarded all the advantages of UWP mentioned above and returned to the Win32 development model, but the world is finding it hard to accept: although it offers new cross-platform capabilities, it still lags like a web app wrapped in a shell.

I often ask myself: Will all the applications my descendants use in the future lag as badly as Teams when resizing the window? Will there be four or five different ways to accomplish a single task within the same system? Will they all need to compete with other processes for resources and scatter garbage all over the hard drive? Will they all require careful verification before installation?

UWP is like a young prince born at the wrong time, or perhaps a passerby who left a bold and colorful stroke in Windows history. It reminds me that once, applications on Windows could run smoothly even on a Celeron processor.