Avalonia Blog

I remember when I wanted to get into C# desktop app development years ago and it was either WinForms or the newer WPF. I chose WPF and it took a while to get a hang of it (mostly I had to either import some libraries or create some common ones to handle variable updates through UI bindings). Unfortunately, WPF always felt unfinished and missing many QoL features. I was hoping they would further refine and make it easier to work with but I guess it was never meant to be.

Windows 10 was coming around corner with UWP being pushed as the big desktop app SDK. Then they ditched that because people just didn't like Windows Store and how they did the apps on it (I also wasn't big fan of it). Then everything went to extremely resource-hungry Electron. Now there is .NET MAUI and and some general WinUI framework [1].

I am utterly confused what is happening with UI development on Windows ecosystem. On rare occasion I want to develop desktop app, I have used Avalonia UI [2] which seems to be something more stable than what MSFT churns out every year or two, can highly recommend that.

Either way, they are really destroying Windows ecosystem by pushing out new framework every few years that always feels half-finished before they move on to the next one. This is, of course, on top of Windows versions in general with how they pile new half-finished UI reworks that just keeps piling on insane amounts of technical debt and legacy for future maintenance.

[1]…

This may be your personal experience but it is used successfully and happily by many in a variety of domains way different to "boring OOP back-ends". No popular general purpose language is confined to a single scenario the way you describe (even Swift and Kotlin are expanding). C# lets you do things like writing a competitive Redis implementation[0], advanced physics engine that beats Jolt[1] or a game engine that does not rely on C++ or C[2], cross-platform applications[3] and so on and so forth. It is possible to successfully do both high level FP style approach for business domain modeling and very low-level data crunching that is competitive with systems programming languages.

[0]: https://microsoft.github.io/garnet/docs/benchmarking/results-resp-bench

[1]: https://github.com/bepu/bepuphysics2

[2]: https://www.stride3d.net

[3]: https://avaloniaui.net

I stopped counting how many generations of UI Frameworks (Modern UI, UWP, WinUI, ...) they released since Windows 7. All of them ware practically unusable. Some reasons:

- They only work for the newest Windows Build
- There are no compatibility packs to target older Windows Versions (7 or 8) or even older Windows 10 Builds (not even the Windows 10 LTSC)
- They are more proof-of-concepts and feel unfinished. After the release, they only get minor updates
- All the minor updates need the newest Windows Build again
- Your customers ask you if you are crazy, because your software doesn't run on a 5 year old PC, that doesn't auto upgrade to the newest Windows version anymore

There are some great alternatives to check out, which even provide cross platform support:

Avalonia: https://avaloniaui.net/

Uno Platform: https://platform.uno/

you should checkout AvalonuiaUI[0] or unoPlatform[1] if wanting to target web/mobile/window/linux/macOS

if building for the web online, asp.net core runs on Linux servers as well as windows

and there's MAUI [2] ( not a fan of this), you are better-off with with the others.

in summary c# and .NET is cross-platform, third party developers build better frameworks and tools for other platform while Microsoft prefers to develop for Microsoft ecosystem, if you get

[0] https://avaloniaui.net/ [1] https://platform.uno/ [2] https://learn.microsoft.com/en-us/dotnet/maui/what-is-maui?view=net-maui-8.0

Check out https://avaloniaui.net as well. It's basically a cross-platform reimplementation of WPF. It's not quite as simple as C#+WinForms or Lazarus+LCL because you don't get drag-and-drop UI designer, and you need to write markup by hand (albeit with live preview). But unlike HTML, it's actually designed for desktop UI apps from the get go, so it's much easier to write for anything non-trivial. And you can still write "quick and dirty" GUI code by directly connecting event handlers to buttons and updating values etc in it, ignoring data bindings and other more advanced facilities.

Win32 and WinUI serve different purposes, they aren’t meant to replace one another. Win32 is simple but also really low level. It’s great to get a window handler and handle low level events but building a modern graphical UI requires at minimum a layout system, that’s where WinUI comes handy.

Also you can now mix Win32 with WinUI via the concept of XAML island. It’s not perfect but you don’t have to be blocked in one world or the other.

Though I personally prefer dealing with WPF via AvaloniaUI, styling with winUI is often too frustrating…

https://www.avaloniaui.net/