One issue the demos reveal is, it doesn't _feel_ like the web. That is, I can't hit Ctrl+F to find text on a page. I can't select text with my cursor. I can't copy the address of a hyperlink. On my phone, I can't hard press on an image and share it to others. Screen readers can't handle it. I can't press a shortcut key to make everything larger.
These all may seem pedantic, but they contribute to the feeling "this is not the real web."
This is the same problem with Java applets in the late '90s, Flash and Silverlight in the early 2000s. They are islands of richness within a web page, but those islands are, well, opaque to browsers, search engines, and virtually all web tooling.
This hits into that concept of what exactly the "web" is. Is it just a media transport system? Or is it something more than that. Of course, we could cite Tim Berners-Lee here or Roy Fielding in this discussion.
But at minimum, I think a lot of us are tired of the app-lification of the web and somewhat wish we could have a bit of the old.
I think some part of UI design degraded with the web, where there used to be a clearer distinction between "user data" and "app chrome" areas than there is today.
I'd also like if we could get back to selections of more complex data types at some point and not just treat everything as text. UI toolkits have all kinds of lists and treeviews to model selectable entities, whereas in the browser, there just a single huge wall of text for everything.
We were all worried about something like Spotify killing off open RSS feeds for them, but there's a growing number of people who have no idea what a podcast is because people are using the term for YouTube channels with full video and no RSS feed (video or audio) to match it. Sometimes language drift is good, but not when it's done on purpose to get rid of a free and open technology in favor of silos.
"Wherever you get your podcasts" only works as long as it's built on top of an open method of syndication.
I know there are strongly held opinions about this, but I for one see no reason why the "application web" can't peacefully coexist, and interlink with, the document web. In my opinion it therefore makes sense to allow for different models for the application web, ones that do not revolve around a document.
On the other hand, if we're just bashing on javascript being the lingua franca of the web, that's a train I'll happily board!
WASM is just one of the platforms that Avalonia supports and so, if you run MAUI on Avalonia, you can run it on WASM.
If you do that though, it is going to be like rendering any other desktop GUI toolkit in WASM. It is not a web app. I mean, it is cool you can do it and MAUI in WASM is better than no web capability at all I guess. But you would never set out to create a web app in MAUI.
MAUI on Avalonia on WASM is really a modern replacement for Silverlight. And it will likely be about as popular.
The really cool thing is being able to target the Linux desktop finally. A lot of people will love that.
And, while MAUI was meant to use native controls on each platform, many people may prefer the Avalonia approach of having your app render the same everywhere.
I havent been in that space for a couple years now so maybe they have gotten better, but I doubt that. I appreciate the heroic efforts of the MAUI team, but I think its just the unfortunate reality.
I was intrigued before I read this. This stuff is a non-starter for me.
That's because MAUI is intended for mobile and desktop apps.
If you want to use .NET for front-end web SPA, you can use Blazor which will behave exactly like you asked.
1000% - as a dotnet developer with 20 years under my belt, I currently don't see the reasoning behind this. With modern browsers, CSS/JS/HTML does SO much, you just don't have XAML. I like XAML (conceptually), but there is JSX for similar functionality, and it is at least compiled into real HTML, not just a applet.
I felt the same with silverlight as well. Why do we keep trying to reinvent Flash? We already have a far superior C# Flash in Unity compiled for Web (kind of a joke, but also not).
We're betting on this over at https://github.com/DioxusLabs/dioxus where we're building a cross-platform UI solution that enables you to do this by having a web-centric API (we are developing our own custom HTML/CSS renderer for native platforms).
I get the value in this and realize it's not for your polished -$500 ARPU consumer social apps, but man this is weird.
(Also if anyone who worked on it is here, it's crashing for me on OSX 26, Chrome 142.0.7444.135, if I run an animation and hit back as the animation finishes)
We got all the plugins back.
Why build a product on MAUI when Microsoft aren't too sure about it.
It is history not the lack of will. At one point the windows division was in shambles (remember vista) and WPF pops up. At another point, the windows and dev division have no answers to the office group (because you know who uses non win tech) so they went react. And then external devs screamed: where is the .net cross platform story so Microsoft acquired xamarin and later form Maui out of it.
It is history not lack of trust. But the outcome is the same: lackluster support for all UI toolkits.
Someone needs to remind those cats that they own the platform. Being able to sanely develop apps for and on that platform should be possible, and UI kinda-sorta matters for that. At a certain point with the MFC they had it dialled in, while pioneering asynchronous browser tech, with many best in class tools. Decades later with a cross-platform cloud-centric stack they have a shrug emoji as big and wide as the eyes can see, and no sense this basic question of development will ever get improved.
Ballmer chanting ‘developers, developers, developers …’ springs to mind.
Windows for many years is just a pile of different browser engines stashed one atop another running broken javascript/xml with react native on top.
The point about them not using MAUI still stands though. From what I understand, the .NET world has either adopted different abstractions like Avalonia, or stuck with tried and tested solutions like WinForms with proprietary controls. After all, they've seen this before with WPF which was never fully adopted by MS either, or with the debacle around Metro/WinRT. You're never quite sure what Microsoft wants you to use or will support in the long term. They also make Blazor, which is a different (and likely more accessible) way to build web apps with .NET.
Since we're on the subject of companies not dogfooding their shiny tech, is Google really using Flutter for their own apps? I feel like the evolution of the Android ecosystem towards Kotlin and Jetpack Compose implies otherwise.
Ive been using the same framework now for 10+yrs on apps in the stores, i wrote a small layer infront of the webviews and can swap out webkit, chrome, edge on demand. You really dont need much, just a constand way to boostrap logic and UI. 90% of code is shared across all platforms, there are def differences in WebView engines that you sometimes come across but those parts just get swapped out with browser specific JS. Ive found bugs and worked with browser teams at all vendors doing this and to see how simple this is with Dotnet these days compared to when i started is refreshing. Its easily the most stable cross-platform framework around, if you are stuck using something like flutter i pitty you, its just eletron with another skin. I can swap out and integrate directly with OS libs when i need to do stuff that the dotnet team hasnt gotten around to yet without re-writing. This has mean i really havnt used MAUI at all, but if i need to or could take advantage of it i can mix it on an Ui element by element basis. I prefer webUIs though, i have the chose to handle anything with either JS, WASM, or a combination. I can use traditional JS frameworks or traditional Native UI frameworks.
If i had started this process later, avalonia seemed to have the closest thing i required. It was just a bit a more complex /based on WinUI (which i dont really enjoy) but it supported all platforms and gave lower level api access. MS were smart, that canabalanised all these community effort and brought them into the fold. Every dotnet webview impl was a successfull community driven project before. They didnt write anything themselves from scratch.
Microsoft Teams was released in March 2017. .NET MAUI was released in May 2022. In 2021, Microsoft replaced Angular with React and moved away from Electron to WebView2 (using the OS' built-in renderer rather than a bundled Chromium). So even the rewrite was a year before MAUI (and they probably started the rewrite before 2021). Plus, part of the point of using React there was that they could basically replace Angular bit by bit.
Microsoft Teams is just older than MAUI. It's like asking why Hadoop is written in Java and not Go or Rust or why Kafka is written in Scala and not Kotlin. Kafka was open sourced in January 2011 and Kotlin came out in July 2011. Kotlin wasn't an option given that they were developing it years before the language was released.
That's not to say that Microsoft's attitude toward MAUI doesn't leave concerns. There was some news a while back about a bunch of layoffs around MAUI. It's always concerning when there doesn't appear to be any dog-fooding going on - is this just some junk they're throwing at us that they don't want to use? I think some hesitation also comes from the Blazor side where it's looking like Microsoft doesn't really see Blazor as a React competitor so much as a way for internal company apps to be made quickly - in contrast to the Google IO presentations on WASM support for Dart/Flutter where they were emphasizing better-than-JS performance.
That said, Microsoft hasn't really released a lot of new (green field) stuff over the past 2-3 years. What product should they have made in MAUI, but didn't? You can't say Teams because that was a giant product way before MAUI even existed. Most of what Microsoft is doing is work on existing products - things they released before 2023/2024 and were in development before MAUI existed. Flutter had a 5 year head start on MAUI.
But there certainly is a feeling that Microsoft doesn't feel committed to it or at least not enough to put its weight behind it.
To be fair, there is no practical way to write native desktop applications using stylistically consistent UI elements AND have it be portable AND in a language that you enjoy using.
As far as I can tell, Windows 11 doesn't even have a toolkit with platform UI elements.
GTK on Gnome is pretty okay and GTK-rs is not dissimilar to React. Who know what MacOS uses but something something Swift XCode.
But I agree, just use web technologies. Write once, ship everywhere (and hum loudly when people complain about poor performance - joking, it's the vendors' fault we have to use web technologies).
Qt also seems to be a good option, though there are licensing considerations for commercial applications.
I’m excited for various upcoming Rust options as well, but right now Electron is the battle tested option.
I am curious though about Avalonia. I’ve heard good things, but it’s definitely a smaller player compared to Electron. I’d most likely choose it over Microsoft’s first party frameworks.
I think it’s better on the server side with ASP.NET.
As far as I have heard MAUI is pretty buggy and has lost momentum. It will probably go on the long list of basically abandoned .NET UI frameworks
Unfortunately Microsoft likes to jump into bandwagons and many engineers at the company seem to like to reinvent stuff rather than adopt. WPF, WinUI2 and WinUI3 all share the same Xaml based structure. So they could have adopted WPF.
It is not that Microsoft doesn't develop advanced UIs with their frameworks. WPF is still well-used by Windows and other Microsoft utilities like Windows Terminal. They are just stupidly abandoning their built up bases for silly industry fads.
They jumped into tablet / touchscreen / hybrid-mobile-desktop bandwagon in late-2010s and tried to force WinUI as an UWP-only feature. It resulted in low adoption. They didn't adopt WPF to have same theming.
When WinUI2 failed, they tried to make modern C++ a reality and tried to remove UWP restrictions which is a good decision. However they diverted quite a bit resources into AI slop generation now and WinUI3 just languishes.
Same for MAUI. They tried to get into multi-platform, multi-device framework as a way to generate leads into Microsoft ecosystem.
They try to use various frameworks and UI stuff to get people hooked into the ecosystem and find ways to upgrade them into Azure and M365 customers. It is meaningless and tiring. All of those could be only WPF.
It is like Google and its many Bazel-like build systems (but not full Bazel) for each of Chrome, Fuschia and Android.
MAUI was to get them through to where everyone wants webapps - served from an Azure backend, of course.
Eventually dumped it and moved to Kotlin Compose/Multiplatform, which is just so much better at achieving a similar goal (though, obviously, without being part of the .NET ecosystem).
> Using .NET MAUI, you can develop apps that can run on Android, iOS, macOS, and Windows from a single shared code-base.
This new development adds Linux and Browser to that list.
I recently tried out .NET MAUI to see how easy it was to build a hello world app. It was quite messy getting it setup on Mac but eventually I got a simple hello world app working. Nice to use XAML again after all these years. I always liked it.
Interesting, I wonder how good Impeller is and if it's actually better than the new Graphite backend of Skia.
the big difference is this
Predictable performance: Impeller compiles all shaders and reflection offline at build time. It builds all pipeline state objects upfront. The engine controls caching and caches explicitly.
or as described here [2] Flutter’s Impeller renderer outperformed Skia. Impeller eliminates runtime shader compilation stalls, delivering lower frame times and more stable performance. For animation-heavy, graphics-rich apps, enabling Impeller significantly reduces jank and provides a smoother user experience.
[1] https://docs.flutter.dev/perf/impeller[2] https://medium.com/@raiden.lpf666/skia-vs-impeller-a-perform...
I wish we can go back to UIs that focus on information density and usability. I love looking at Japanese websites because of this.
You can check out the Avalonia demo reel to see what you can already do with the .NET GUI stack that MAUI now uses on Linux and on the web: https://avaloniaui.net/showcase
WPF & WinForms are also still around
I first tried Maui because its seemingly so highly rated and recommended. It turned out to be a complete nightmare. Even just installing it didn't just work, I had to spend 2-3 hours just to get that going and then when trying some basic things for my UI it turned out to just not be supported.
The next on the list was AvaloniaUI and wow, it was the complete opposite experience. Installation was a breeze and with only a marginal bit of googling I managed to do all kinds of things such as making a top-most only borderless transparent window etc.
The interface in Visual Studio could be a bit better overall, but compared to Maui its light-years ahead.
I go to "Launch MAUI in your browser" [0] in section "Try It Right Now". I click on "Word puzzle - A word puzzle game", third of the demo apps. I click on the "Randomize" button. Tiles start shifting around. I click on the left arrow at the top to go back to the main menu. The whole thing becomes locked with the word puzzle on the background and the main menu on top of it. Nothing is clickable any more.
This happens on various different browsers.
[0] https://brave-sky-0c7a41a03-preview.westeurope.3.azurestatic...
7/9 = 1
Tried the RPN calculator:
Can't push any numbers to the stack, so I can't use any operator.
I'm wondering why all the demos of modern UI toolkits look and feel worse than Delphi 1 demos from prehistoric age.
I'm sure there's a better place to track the progress on that.
Xamarin turned into dotnet, Xamarin.forms turned into turned into Maui. Name another large tech company that has embraced community projects like this and pushed provided enterprise support for community driven stuff over the same period.
I was writing cross-platform apps before Flutter, angular, or whatever other language you choose for 11yrs now. Find another framework thats done this before the scare tactics of "MS will abandon this" rhetroic. dotnet is the premier cross-platform enterprise ready framework full stop. No other framwork has the backwards compatiblty while maintaining paritity with the latest OS APIs. No other framework can serve millions of pages per/sec while supporting pixel perfect UIs and code-reuse. They have invested so much money in building automation that means as soon as the OS releases an API, your getting access to it. In real world terms, this is what counts if you want to build cross-platform stuff that your clients cant tell isn't native.
I run the same code from 2014, today, in apps in all the stores. Over the years all i have had to change is various namespaces to take advantage of the latest enhancements. Code that ran on dotnet4, silverlight, xamarin, still runs today on dotnet10. I share 90% of code across all platforms yet clients cant tell they are not native apps. Thats what i call return on investment.
Where there is intense confusion in these comments is in thinking that MAUI is a web application framework. MAUI is "cross-platform" as you say but really mobile first with desktop brought along for the ride. It is in no-way intended to be a web application tech.
Avalonia has created an Avalonia back-end for MAUI which means running MAUI apps wherever Avalonia is supported, and that includes WASM. So now you can run MAUI apps in a browser. You can but that does not make MAUI web tech.
I can run Windows 95 in a browser. That does not make Win32 a web API.
The sliding puzzle is really finicky, have to try multiple times to slide stuff, the top left (back) arrow stopped working altogether until I refreshed the page, which of course takes you back to the original page... The time picker looks awful with the numbers not centrally aligned to the control (they look too high), and it's finnicky to use / same with the date picker.
Awful.
https://avaloniaui.net/blog/avalonia-partners-with-google-s-...
"What is the Avalonia MAUI Backend?
At its core, the Avalonia MAUI Backend enables you to keep your MAUI codebase while replacing the rendering layer with Avalonia."
Which tells me exactly nothing. what even is MAUI, maybe some polynesian deity? :-P
I know, I know, I can google stuff. But still...
I really love C# and the .net ecosystem, but they just haven't made it work for web.
I wouldn't use it for consumer apps because it requires a Websocket connection to maintain state and probably doesn't scale very cheaply... but for business applications or personal tools it's actually kind of insane how much functionality you get out of the box (at least by the standards of statically typed languages).
To replicate this example in Typescript, I'd probably still be installing packages in the time it took to write the 20 lines of code it contains: https://learn.microsoft.com/en-us/aspnet/core/blazor/compone...
There is ASP.NET of course and Razor Pages. We all use apps built with these every day without even realizing it. There are other great frameworks as well.
I do not even see Blazor as a real web technology but of course it is positioned that way.
MAUI is a "cross-platform" and frankly mobile first UI framework. It was never meant for the web.
If it's better than what MAUI provides and you can support it for years, I'm sure that could take over and many people would use it instead. But... will you and why?
QT Framework is still one of the best for cross-platform desktop applications when speed is key.
Also C# and .net overall are so damn good.
Anything to abolish the js and constant hacks upon hacks
.NET Maui running on windows seems like a more logical first step to prove the organization buys their own dogfood.
To clarify, it's using React Native XAML, where XAML is Microsoft tech for building UIs. So they are dogfooding but they have too many UI frameworks to choose from.
I would have much preferred a React-Native-style approach, where they render to true HTML instead. Even then, WASM files are too heavy for quick loading times without good internet (and sometimes even with).
The projects I see that would most benefit from something like this are complex internal apps that need to be used in different places but aren't worth porting over/rewriting, but they would also suffer from terrible UX given the constraints of this design.
For all other projects, it makes for more sense to use React Native.
Would you complain that Qwasm/Dwasm doesn't follow HTML standards of accessibility?
If Qwasm is referring to Quake, it absolutely should have, for example, legible color contrast and be usable if you are colorblind.
This could have been so much better.
Edit - for those unfamiliar: https://en.wikipedia.org/wiki/Microsoft_Silverlight
This is somewhere quite a few tools fall down. For example, for web: Rendering to canvas doesn't create the dom nodes required to hook into the tools, and creating the nodes appropriately can have a significant performance impact.
What about native a11y tools and tech.. there are some ios specific ones that you'd expect on an ios app for example.
I can't help but think of Joel Spolsky's Things You Should Never Do (5) - the transition from Xamarin to .NET MAUI feels like a very similar mistake to Netscape. All of the battle tested Xamarin code, documentation, community examples, packages, etc. is now dead and has to be converted over to .NET MAUI.
On top of that, XAML just doesn't do it for me - having to deal with code-behind, MVVM view models, custom converters, and the actual XAML files themselves is insane for what is usually just a a single file in JS. The fact that you need to write a "InvertedBoolConverter" (4) just to flip a boolean is the most Microsoft thing ever. MAUI feels like it's designed just to keep a large development team busy. I'm not joking, we have a 42 line file that's only purpose is to flip booleans for XAML views.
We're a C# shop so it was nice to share our common C# with our desktop application, but I don't think it was worth it in the end. Sure JS has its problems, but I'll take those problems any day over MAUI.
I hope Avalonia can fix .NET MAUI - it'd be a massive kudos to them if they can smooth it over, but I can't say I'd willingly rely on this project long term.
1 - https://github.com/dotnet/maui/pull/15612 2 - https://github.com/dotnet/maui/issues/8191 3 - https://github.com/dotnet/maui/pull/15655 4 - https://learn.microsoft.com/en-us/dotnet/communitytoolkit/ma... 5 - https://www.joelonsoftware.com/2000/04/06/things-you-should-... https://github.com/dotnet/maui/pull/16965
[1]: https://docs.avaloniaui.net/docs/reference/built-in-data-bin...
What they are announcing is being able to run MAUI on Avalonia such that you can run your MAUI apps on any Avalonia supported target. This includes both Linux and WASM, neither of which is supported by MAUI directly.
[1]: https://avaloniaui.net/blog/bringing-wayland-support-to-aval...
Plus, it is my assumption/understanding that there's no way 3rd party controls will be able to run on Linux/Browser unless they're built directly against MAUI API without any Native our Skia dependencies, which is almost never the case from the libraries I've been using.
Am I right?
**insert inception meme here**
Joking aside: this points to MSFT moving away from the whole Mono/Maui investments and into Aspire or whatever they call it. Without MSFT backing this I am not sure if there is much more future left for MAUI (or dotnet on mobile in general).
Avalonia is great though.
Yes. They're also looking at offering Impeller as a render option:
https://avaloniaui.net/blog/avalonia-partners-with-google-s-...
I'm curious to see if .NET MAUI will surpass Xamarin and actually get serious adoption. They have to figure out the third party binding issue.
https://www.reddit.com/r/dotnetMAUI/comments/1l1xiib/entire_...
MAUI is nice, and I'm glad it's getting decent Linux support now, but I would never use it in the browser.
Avalonia's big money ticket is taking old WPF projects, making minor changes to the XML to load their tools, and instantly making the projects work on macOS/Android/iOS/etc. (for an enterprise fee, of course). Great for forcing internal .NET applications built to run on Windows Vista into the modern world, but I don't think their web platform is a good idea for new projects because of the massive overhead you end up with.
Do you want to build an app using MAUI? Unless you build an app that barely deviates from the template, expect to desperately search through decade old Xamarin documentation and figure out the details through painful trial and error.
Good luck.
It is a way to get people choosing the "official" path (ie. choosing MAUI) to experience Avalonia. They are hoping you come for the MAUI and stay for the Avalonia and become an Avalonia developer.
As for, why choose the Avalonia version of MAUI, there are three reasons: - Linux support (the big one I think) - Drawn framework (same renderer on all platforms) - WASM support (probably useful sometimes but not the real draw)
They are making a big deal of WASM here because it is easy to demo. We can all go into it and run it. But do we want to use it for our apps?
As for, why not Avalonia directly? To loop back to the beginning, it is because you do not yet know Avalonia and trust it. The Avalonia team is hoping this helps with that.
MAUI is supposed to be a wrapper around native widgets. The fact that they had to use Avalonia under the covers to get it to work on Linux seems to defeat the point. (Avalonia is a complete UI toolkit, like Qt or Flutter, that owns the entire stack from XAML to pixels.)
This is absolutely horrible and I hope I never have to use it on the web - right click doesn't work, my plugins don't work, I can't even open DevTools and when I manage (before the app has loaded), it's just a <canvas> element in the page. I know a lot of people put work into this and something is probably better than nothing, but actually no, I think such solutions are disgusting.
If you're gonna claim cross platform, don't just stoop down to the lowest common denominator and write a bunch of pixels to the screen, use the damn system UI solutions, or in the case of web apps - HTML, CSS and JS/WASM. I already take an issue with Electron (Lazarus lcl did things right, in contrast) but realize that it yields a lot of utility, yet these canvas based approaches for web apps feel like a step too far.
Yet obviously nobody can admit that they can't do the heavy lifting needed to support multiple different target platforms for the same widgets in a way that respects the corresponding platforms, while also still wanting to ship something. In this case, I think nothing is better than something, if that something is so bad.
[0] https://mauikit.org/ [1] https://github.com/dotnet/maui/issues/35
I hope Microsoft delivers though, we need more alternatives to React + RN or Flutter.
I wonder how hard would it be to go back to visual designers like we had with Delphi or VB6. There were flexible layout container components which helped a lot when adapting forms to varying screen resolutions.
Pathetic that MS doesn’t manage to do this themselves.
Even more pathetic that MS doesn’t actually use it for any of their products, so forgive me if I have very little faith in the future of MAUI with all its bugs.
This feels like it could be a competitor to QT, but without a real-time operating system like QNX, what's the point?
React Native won out over Fluter, Java Applets lost to HTML5 / JS, Framer is much better than Wordpress.
Time and time again, clever simulations on top of the native world are never worth it.
A chrome browser by itself can't work that - it's great for many things, but not for Creative Tools.
If you are building a Windows desktop application though, Microsoft does not want you to use MAUI. You use MAUI because iOS and Android are your top platforms and you want to target macOS and Windows without writing dedicated applications.
Linux has always been missing. This Avalonia port fills that gap.
You would not target the web with MAUI either. I guess "you can" now because WASM is one of the platforms that Avalonia supports. Again, I guess you might if you already have a MAUI app and do not want to create one for the web. But you would never set out to create a MAUI app for the web.
Canvas rendered cross-platform UI frameworks like Flutter & Avalonia targeting browsers (WASM), might shift the balance back in favor of desktop UI.
1) In today's American political climate I think it's appropriate to express appreciation for immigrants to like Miguel de Icaza who dragged Microsoft kicking and screaming into cross platform .NET and is the godfather of .NET Maui
2) As someone who came up developing desktop apps for Windows and Mac, I never liked developing web applications. There was so much lacking, but now developing web apps is becoming like developing desktop apps. Now you get/put your data from HTTP calls instead of file system and database calls or with Blazor and SignalR you don't even have to think about those. This may seem obvious to younger programmers today, but it would have seemed like magic back in 2004 when Dymanic HTML and Ajax (both Microsoft) were being invented.
3) I'm grateful Microsoft has changed their old ways to be a forward thinking company. They still have problems that any GIANT, Inc. organization has, but let's not forget how far they've come.