What 16,663 Windows Apps Are Built With

We collect Windows apps from winget, the Microsoft Store, and direct developer downloads, then download each one and read the shipped binary: the PE executable and the DLLs that ship beside it. We infer the runtime from what the app actually links and loads, not from a source repo or a published manifest. Only 1,685 of the Windows apps we track are open source, so for the rest the binary is the only record of what they run.

Here is what the Windows apps we track are built with, August 2026.

We ran the same scan on the Mac, where one stack owns the platform: in this same August snapshot, Swift, Objective-C and Cocoa together account for 56.2% of the Mac apps in the corpus. Windows has no equivalent. Its two largest runtimes are nearly tied, and the second of them barely exists anywhere else.

Native code and .NET split the platform

Native C/C++, 32.3% (5,374). Win32 and the C runtime, compiled straight to a PE binary. The oldest way to write a Windows app, and still the most common one in this corpus. It is also the lightest: a median of 15.9 MB, against 67.4 MB for a Windows app of any kind.

Google Chrome7-ZipVLCTelegramNotepad++

.NET, 29.5% (4,909). Microsoft's managed stack, from Windows Forms and WPF through to .NET 10. Median 66.5 MB. A live query the same day finds 1,026 Windows apps still shipping on .NET Framework, the Windows-only line Microsoft froze at 4.8, which is about a fifth of the .NET apps we track running the old runtime rather than the modern one.

WhatsAppCalculatorPhotosHandBrakeProton VPN

Electron, 13.9% (2,312). Bundles its own Chromium and Node, which is why the median one is 391.1 MB, roughly six times the median Windows app.

VS CodeSlackSignalPostmanObsidian

Tauri, 4.5% (757). Rust behind the webview the operating system already ships. At a median 23.7 MB it is about a sixteenth of the median Electron app, and it sits ahead of Qt, Go and Rust-native on Windows.

GroupMeGrammarlySeelen UIFirezonenuclear

Go native, 3.7% (620). Compiled to one binary with no separate runtime to install. On Windows these are mostly infrastructure tools: version control, networking, containers. Go is six times bigger a share here than on the Mac.

GitWireGuardTailscaleDocker CLI

The long tail

Qt, 3% (505). The mature C++ cross-platform toolkit, and still where a lot of serious open-source desktop software lands. Median 143.3 MB.

OBS StudioWiresharkKeePassXCNextcloudMuseScore

Rust native, 2.9% (489). Rust used for the whole app rather than the backend of a webview shell. Median 30.2 MB. Terminals and developer tools, mostly.

AlacrittyWarpSniffnetstarship

Python, 2.7% (458). Apps that ship a bundled CPython interpreter. On Windows that bucket mixes Python-first applications with large C++ ones that embed Python for scripting, which is part of why the median is 180.3 MB.

calibreAnkipgAdminBlenderInkscape

Flutter, 2.6% (441). Google's UI toolkit, one codebase from phone to desktop. Of the cross-platform UI toolkits here, Electron, Tauri, Qt and the JVM, it is the only one with a bigger share of Windows than of the Mac, where it sits at 2.1%.

Ente AuthHiddifyInvoice NinjaServer Box

JVM, 2.5% (412). Java and Kotlin, which on Windows means developer tooling and document utilities. The heaviest median in the ranking after the browser-bundlers, at 208 MB.

DBeaverIntelliJ IDEAArduino IDENetBeansPDF24

After that it thins out fast: CEF at 0.4% (65), Wails at 0.2% (41), Delphi at 0.1% (18), each still shipping.

The runtime that does not travel

Most of that list ships on both operating systems in roughly similar proportion. Electron is 13.9% of Windows and 18% of macOS. Tauri is 4.5% and 7.4%. Qt, Python, Flutter and the JVM each sit within a couple of points of themselves. Go leans to Windows, as you would expect from what Go is used for.

Then there is .NET, at 29.5% of the Windows apps we track and 1.1% of the Mac ones. In counts: 4,909 against 130.

.NET the runtime has been cross-platform for a decade. .NET the desktop app has not moved. The likely reason sits a layer below the runtime badge: Windows Forms, WPF and WinUI are Windows-only, and the cross-platform successors are young. We do not measure which UI layer each .NET app uses, so treat that as a reading rather than a count. What we can say is the outcome: in the apps we track, a team shipping a .NET desktop app is, in practice, shipping a Windows app.

This is the thing a cross-platform runtime table hides. If you sell a desktop SDK and your coverage table reads Electron, Tauri, Flutter, you have described the Mac reasonably well and missed roughly three in ten Windows apps.

Windows borrows its browser

Electron's pitch and its cost are the same fact: it brings its own browser. Windows offers a second option, because the operating system already has a Chromium in it. WebView2 lets an app render web UI in the system webview, and Microsoft keeps that component updated.

Querying the corpus directly, a few dozen rows further along than the snapshot above, 3,278 Windows apps ship the WebView2 bindings against 2,359 that bundle Electron. Across the apps we track, the more common way to put a web view in a Windows app is to borrow the one already on the machine.

Read that as a presence signal and a floor. We are counting apps that ship the WebView2 loader, which is good evidence the app embeds the system webview, and not proof that the whole interface is one. It turns up inside apps we classify as native, and inside .NET apps most of all.

The distinction matters for anyone tracking browser-engine exposure. An Electron app freezes a Chromium at build time and ships it. A WebView2 app usually renders on whatever Chromium the machine currently has, though the component can also be shipped pinned. Same web UI, different update stories.

Still shipping 32-bit

Of the 15,001 Windows apps where we can read the PE header, 19.3% ship a 32-bit binary and nothing else. Another 23% ship both. Just over half are 64-bit only, which leaves about two in five of them still putting an x86 binary in the box in 2026.

Arm64 is the other end of the same question. 386 apps, roughly one in forty of the ones we can read, include an Arm64 slice.

The Mac contrast is instructive. 14.6% of the Mac apps we track are Intel-only, and that is with Apple having moved its entire hardware line in two years and stopped selling the old architecture. Windows on Arm has existed longer and has no such forcing function, and it shows in what actually ships.

Neither number is going to move because developers read a blog post. They move when the platform owner removes the option.

Where the data comes from

Every figure is an August 2026 snapshot, measured by reading what each app ships rather than what its developer publishes. Runtime shares are of all 16,663 Windows apps in the corpus; the architecture figures use the 15,001 of them with a readable PE header; the WebView2 and .NET Framework counts come from a live query against the same corpus on the same day. Most of these apps are closed source, so the shipped binary is the only place this information exists.

The example apps under each runtime were picked to be recognizable and each one's runtime was confirmed against its own record. They are not a ranking.

We will run this again as the corpus grows, and the .NET share is the number we expect to argue about. Want a custom cut, or the per-app data behind any of these figures? Come ask us.