Comet VS ReactiveUI

> the first, MVP-style, attempt will be using Electron.

Good choice.

If you want to stick to HTML...WebView2 is suppose to replace it, but it assumes your backend code is .NET or C++, instead of JS/Node.js. Microsoft Teams is using it.

If you want to use native Windows UI components from JS code, then React Native for Windows is recommended. Facebook Messenger is using it.

All approaches require C# or C++ modules to be used to interact with the Windows Platform. Or there is: https://github.com/tjanczuk/edge.

The recommended approach is WinUI 3 which would involve C#/C++ and XAML.

To SwiftUI/React/JetPack are called module-view-update (MVU). There is an MVU for C# called Comet. https://github.com/dotnet/Comet#key-concepts

The benefit at least with the approach instead of embedding Avalonia inside Maui is you could potentially use non xaml frameworks for ui as long as they support Maui as a target. Stuff like Comet or Blazor mobile bindings would be possible aside from xaml. Especially if they're coming from Blazor web or code based ui frameworks like flutter which makes it appealing.

That was using the experimental Comet extension and lib, based on .NET MAUI. You can find instructions here: https://github.com/dotnet/Comet

There are also experimental libraries for .NET MAUI, which let's you create UI only with C#: Comet, MauiReactor

The MVU library is called Comet. The lead developer recently left Microsoft but im still seeing commits on the repo which is a good sign!

Yeah the hybrid blazor stuff is interesting. So is https://github.com/dotnet/Comet.

The XAML API is definitely more compact overall which is unfortunate, mostly because a lot of the devs prefer XAML. I've always preferred code-based UI though. Theres some 2ndish/3rd party options with Comet, which changes the UI pattern to MVU and C# Markup, which might not be updated for MAUI yet.

All the C# parts for Hybrid (including the components themselves) are running natively. Only the UI part (e.g. html, css) under the Web View is running web tech (html, css) under a native webview of the platform. But you can also add native MAUI controls if you wanted to (either via XAML, or Comet) and mix and match as that webview control that Blazor uses is just a MAUI control.

There is an alternative using MAUI .Net Comet

ReactiveUI is based on Rx and very popular in the .Net world: https://www.reactiveui.net/.

I use PropertyChanged.Fody all the time and it works fantastically and consistently for implementing INotifyPropertyChange. It is even smart enough to understand dependencies within your get/set functions (should you choose to have custom ones) and notify that property if any of it's dependent properties change. While we are on the subject, if you are using MVVM with observables, you should really check out ReactiveUI. It is wonderful.

Personally I learned to use rx and observables by starting to use ReactiveUI combined with DynamicData for my WPF app MVVM architecture. It was maybe not to best choice out there, but I learned to work with it and some things it allows to do is awesome.

My favorite framework is Reactive UI but it's a bit more advanced than most MVVM frameworks since it uses Reactive Programming. You can still try its most basic features, though.

There is a lot of overlap between WPF and Avalonia so I would start with either one of those. Most certainly Avalonia if you plan to do cross platform dev. I would also highly recommend that you learn and conform to MVVM and dependency injection for your architecture in order to write clean, maintainable, and testable code. My recommendation is ReactiveUI. It leans heavily on more modern patterns like Reactive extensions and IObservable and it can do so much more than just MVVM. As such, it is also very similar to Angular so the concepts will transfer easily if you ever need to do web development. On a side note, Pluralsight has a nice quick course on SOLID design principles. If your code is a mess, it would be a good idea to take a course on this though learning MVVM will be a big step in the right direction.

Also, about data binding and reactivity if you really enjoy WinForms, nevar forget!! https://www.reactiveui.net

Your UI needs to bind to something that can programmatically notify it about changes, we call these things View-Models. Usually View-Models implement INotifyPropertyChanged interface (another key interface is INotifyCollectionChanged that is responsible for notifying collection views that number of items is changed and they need to update the UI accordingly). You can do that (the implementation of the interface) manually or use some library to do that for you just to cut some boilerplate code (e.g. ReactiveUI + Fody or Microsoft.Toolkit.MVVM or maybe even this or this).

Some projects like ReactiveUI take on a more webapp style project structure, with resources being in some static resources folder and all code being in a src folder.