Built with .NET:
Where the Apps Nobody Counts Actually Are

Ask any group of developers: which application that people actually use every day is built with .NET? The first answer is KeePass. The second is Paint.NET. Then it goes quiet.

That silence is the subject of this post. Because it has less to do with .NET than with how we measure reach.

Why Paint.NET is the wrong example

Paint.NET is a solid program. The current version is 5.1.12 from 8 March 2026, and since version 5.0 all of the legacy C++/CLI code has been ported to C#. But the moment it comes up, the same comparison starts: why would anyone install Paint.NET when GIMP exists? That argument is hard to win, which is why the discussion nearly always dies there.

The mistake is not the answer, it is the category. .NET does not have its end users in image editing. It has them in games and in Windows utilities. And there the balance sheet looks completely different.

The measurement error

The obvious route to a stocktake runs through GitHub: filter by language:C#, sort by stars, take the top ten. The result is useless, for three reasons.

First, the language filter loses precisely the big applications.

GitHub assigns a repository to whichever language has the most bytes. Microsoft’s PowerToys, with 138,662 stars, therefore shows up as “C” even though roughly a third of the code (32.49 percent) is C#. HandBrake, with 24,386 stars, also shows up as “C” even though its entire Windows front end is a WPF application accounting for 24.02 percent C#. A language:C# search finds neither.

Second, stars measure developer attention, not usage.

The most-starred .NET application on GitHub is v2rayN, a proxy client with 116,177 stars that few people in Germany are likely to know. Right behind it sits shadowsocks-windows with 59,557.

Third, the biggest .NET applications are not on GitHub at all.

KeePass lives on SourceForge. Paint.NET, MusicBee, Terraria and Stardew Valley are closed source. Zero stars, millions of users.

Forks measure something other than expected

The fair objection to stars is that you cannot buy forks. True, but forks count developers, not users. What they actually reveal only shows up in the stars-per-fork ratio (as of 26 July 2026):

Repository	Stars per fork	What it really is
eShopOnContainers	2.4	Microsoft sample project
shadowsocks-windows	3.7	client everyone builds for themselves
CleanArchitecture	4.8	project template
ShareX	10.0	finished application
Files	15.9	finished application
Playnite	20.9	finished application
Flow Launcher	24.4	finished application
G-Helper	26.4	finished application
UniGetUI	29.0	finished application

This inverts the common reading. Many forks mean template, library or self-assembled client. Few forks alongside many stars mean a finished application that people install rather than copy. For a list of real applications, a high ratio is the seal of quality, not a low one.

The one hard usage number

There is one number that genuinely counts installations: the sum of all asset downloads across all GitHub releases. Queried on 15 September 2026:

Application	Asset downloads	Releases
osu!lazer	259,537,775	651
PowerToys	146,228,248	139
v2rayN	65,668,425	337
HandBrake	59,037,961	54
Greenshot	54,752,741	126
ShareX	33,681,209	90
NAPS2	14,117,083	109
Subtitle Edit	13,406,642	181
G-Helper	10,314,782	298
Playnite	4,481,099	164
Duplicati	1,486,880	268
Files	90,125	141

Two caveats, without which the table would be dishonest. Updates are included, so projects with many releases are systematically flattered. And only the GitHub channel is counted: Files lands at 90,125 downloads against 45,413 stars because it ships through the Microsoft Store. That contradiction shows that these numbers measure different things.

Games

This is the strongest case, and it is almost never made in .NET discussions.

Terraria passed 70 million copies sold in May 2026 for its 15th anniversary: 39.6 million on PC, 19.7 million on mobile, 10.7 million on consoles. Averaged over the year, roughly 461,000 people play it daily on PC, the peak sits at 1.4 million, and average playtime per buyer is 101 hours. Written in C# on Microsoft’s XNA.

Stardew Valley passed 50 million copies sold at its tenth anniversary in February 2026, according to its developer Eric Barone. Originally XNA, on MonoGame since 2021. Barone subsequently donated 125,000 US dollars to MonoGame plus an ongoing monthly contribution, a remarkable gesture for a one-man project.

Celeste runs on C# via a small in-house framework called Monocle on top of XNA, ported with FNA and MonoGame. osu! has more than 18.5 million registered accounts (as of September 2024). OpenRA, the open engine for the early Command and Conquer titles, has 17,374 stars.

And then comes the point that should really end the discussion: Unity. By its own account, 70 percent of the top 1,000 mobile games are made with Unity, alongside more than three billion mobile downloads per month and over 1.3 million active creators monthly. Well-known titles include Among Us, Hearthstone, Genshin Impact, Subnautica and Cities: Skylines II.

The scripting language is C#, the game itself is written in it. The engine, by contrast, is only partly C#.

That ran on Mono, which is why you had to distinguish carefully between “uses C#” and “runs on .NET”. That distinction is set to disappear: Unity 7 is built on CoreCLR, the runtime of today’s .NET, and leaves Mono behind entirely. An early beta is announced for December 2026, the full release for the first quarter of 2027.

Windows applications many people know

PowerToys is Microsoft’s own toolbox for power users and reaches 146.2 million downloads. HandBrake, at 59.0 million downloads, is one of the best-known free tools for converting video. The core is C, but the Windows front end is WPF.

In screenshots, two of the most downloaded tools run on .NET: Greenshot at 54.8 million and ShareX at 33.7 million downloads. Anyone taking screen captures on Windows may well be using a C# application without knowing it. Add NAPS2 for scanning and PDF at 14.1 million, and Subtitle Edit for editing subtitles at 13.4 million.

KeePass, finally - C# on .NET Framework, and on Linux and macOS via Mono: Consumer Reports counted it among the four most widely used password managers as far back as 2017.

Mobile, honestly

On mobile the balance is thinner, but not empty. Microsoft builds its own Azure app with .NET MAUI, and Microsoft’s customer showcase lists, for example, My Ride K-12 by Tyler Technologies.

And because a list without a counterexample is just advertising:

Bitwarden did not migrate its Xamarin apps to MAUI.

In January 2025 the password manager moved to native Swift and Kotlin, citing performance, faster updates and better access to platform innovations. Anyone writing about .NET on mobile should mention that departure.

And in the backend

Many .NET applications are never seen at all, because they run on servers. Two examples almost everyone is likely to have used:

Bing runs on .NET. According to Microsoft, the search engine was already running the .NET 10 release candidates in production, with noticeably better response times.

Stack Overflow has always used SQL Server for its public sites. During the move to Google Cloud in 2025, some older applications there still ran on the classic .NET Framework, in a Windows Kubernetes cluster. Stack Overflow for Teams, by contrast, runs entirely on modern .NET.

Worth reading

The real value of this list lies elsewhere. Mature desktop applications are lying around in the open here, and you can learn architecture from them. Five of them deserve a closer look. The details come from the source code, with the numbers last checked on 15 September 2026.

OpenRA pushes composition to its limit. The directory OpenRA.Mods.Common/Traits/ holds 501 files, and most are tiny. The actual content of Huntable.cs is three lines:

[Desc("This actor can be targeted by the Hunt activity.")]
public class HuntableInfo : TraitInfo<Huntable> { }
public class Huntable { }

A capability here is an empty marker class, and the [Desc] attribute doubles as the documentation from which the mod reference is generated. No inheritance tree, no base class with thirty virtual methods. If you want to understand what composition over inheritance means in practice, there are 501 examples here.

osu! solves a problem most projects never even attempt: how do you test a user interface automatically? The answer is 888 files matching TestScene*. A complete visual test looks like this:

AddStep("create initial", () => { Child = explosion = new ParticleExplosion(...); });
AddWaitStep("wait for playback", 5);
AddRepeatStep(@"restart animation", () => { explosion.Restart(); }, 10);

That is a declarative script which runs in continuous integration and which a human can watch at the same time in the bundled test browser. For a rhythm game where timing and animation are the core function, that is not a gimmick but the only meaningful safety net.

Lively Wallpaper, at roughly 430 C# files, is small enough to understand in an evening and still demonstrates process isolation under real conditions. The WinUI front end talks to the core over gRPC, each playback technology runs in its own process (CefSharp, WebView2, VLC, Windows Media Foundation), and on top of that sits a small separate program called Watchdog. Its sole purpose is stated in its own class comment: it cleans up third-party programs running as wallpapers when Lively itself is killed from Task Manager. It is driven by a three-command protocol on standard input: ADD, RMV, CLR. The whole file is under a hundred lines and solves a problem that, in larger applications, tends to end up in a maintenance thread with a state machine.

Files is the best look at contemporary Windows development, though not as a style guide. The file manager ships WinUI 3, its own source generator, CsWin32 for the Windows calls, a separate server process and two test projects. The application’s entire service graph sits in AppLifecycleHelper.cs, a 638-line file containing 77 AddSingleton calls. That is instructive in both directions: you see the complete dependency structure of a real application in one place, and you see where it leads when everything is a singleton. On top of that, Files reaches for a service locator via Ioc.Default instead of constructor injection, and ShellViewModel.cs has grown to 117 kilobytes.

Subtitle Edit is the case that surprised me most. I expected an overgrown WinForms codebase. In fact the main branch is a complete rewrite on .NET 10 with Avalonia 12, CommunityToolkit.Mvvm and Microsoft.Extensions.DependencyInjection, cross-platform down to Linux. Version 5.2.0 was released on 10 September 2026. The project structure is cleanly separated into core logic, UI logic, presentation and a standalone console tool, with five test projects including benchmarks.

And then src/ui/Features/Main/MainViewModel.cs contains a single class of 33,894 lines in one file. In July it was just under 24,000.

Both at once, in the same project: modern stack, exemplary layering, five test projects - and a 1.3-megabyte view model. If you want to see what real software looks like rather than conference slides, read exactly that. Cleaning up is a task at the class level, not the architectural one, and the architecture here is sound.

Conclusion

There is no reason for the silence. One of the best-selling games of all time is written in C#, Unity scripts in C# and moves to CoreCLR with version 7, and two of the most downloaded screenshot tools on Windows are .NET applications.

You just do not see it. Partly because these applications do not advertise it: there is no “Built with .NET” badge on Terraria’s start screen. And partly because the usual rankings count repositories instead of users, and because even GitHub’s own language filter overlooks the biggest candidates.

The applications are there. They had simply never been collected in one place.