The .NET Cross-Platform Showdown: MAUI vs Uno vs Avalonia (And Why Avalonia Won)

Source: Dev.to

Introduction

I’ve been writing .NET code since the first beta. Over three decades of professional development, I’ve seen the good, the bad, and the abandoned. I love C#—it remains one of the most elegant languages for building production software. But Microsoft’s UI‑framework strategy? That’s been a different story.

The Problem

I needed to port a tool I’d built in SwiftUI to Windows. What started as a simple requirement turned into a deep dive through Microsoft’s fragmented ecosystem and ultimately led me to abandon MAUI entirely. Below is what I learned.

My Current Role

• Title: Developer Advocate at Ditto
• Focus: Helping developers build applications with Ditto, an offline‑first mobile database platform that enables peer‑to‑peer mesh networking and real‑time data synchronization.
• Key Value: Applications that function reliably regardless of network connectivity, using Conflict‑Free Replicated Data Types (CRDTs) to sync data over Bluetooth, Wi‑Fi, or LAN without constant cloud access.

The Original Tool

• Name: Edge Debug Helper
• Purpose: Debug Ditto apps when working with the MongoDB Connector.
• Initial Stack: SwiftUI → functional macOS tool built in a few days.

When Windows developers asked for a cross‑platform version, the limitations of SwiftUI became obvious.

First Alternative: Rust

• Pros: True cross‑platform capabilities.
• Cons: Steeper learning curve, limited UI libraries, and spending more time fighting the borrow checker than building features.

Returning to .NET

I’ve used .NET throughout my entire career, so the natural question wasn’t whether to use .NET—it was which .NET UI framework to choose.

Microsoft’s UI Framework Track Record

This pattern represents millions in wasted development effort across the industry. Every few years Microsoft pivots to a new framework, and developers are left rewriting applications or maintaining legacy code. It’s exhausting.

The MAUI Experience

Why I Started with MAUI

• Official Microsoft cross‑platform framework → the obvious first choice.

What Went Wrong

Bottom line: MAUI isn’t ready for the job I needed. It feels like another promise that will likely end up abandoned, just like Silverlight, UWP, and previous frameworks.

Exploring Uno Platform

First Impressions

• Tooling: Everything MAUI should be but isn’t.
  • Hot Design with AI assistance
  • Real‑time XAML updates
  • Figma integration

These features make writing XAML applications genuinely enjoyable. Uno’s developer experience far surpasses MAUI’s.

Drawbacks

• Project structure complexity: Multiple projects, conditional compilation, and platform‑specific implementations felt heavier than necessary for someone returning to full‑time .NET after several years.
• Linux support: Available, which puts Uno ahead of MAUI, but not yet production‑ready.

Community Interaction

I documented issues during livestreams on my YouTube channel. The Uno team responded quickly, releasing updates that resolved many of the problems. Their care for the developer community is evident, and my interactions with them have been extremely positive.

Takeaways

1. Microsoft’s UI framework churn creates real pain for developers who need stable, long‑term solutions.
2. MAUI currently falls short for desktop‑heavy, cross‑platform scenarios, especially when Linux is required.
3. Uno Platform offers a superior developer experience and better cross‑platform reach, but its project complexity and still‑maturing Linux support mean it isn’t a perfect drop‑in replacement yet.
4. Community‑driven frameworks (like Avalonia, which I referenced) and responsive vendor teams can make a huge difference in real‑world productivity.

Closing Thoughts

If you’re in a similar spot—needing a truly cross‑platform .NET UI for macOS, Windows, and Linux—you’ll likely have to weigh the trade‑offs between tooling polish (Uno) and project simplicity (MAUI). Until Microsoft delivers a stable, production‑ready desktop experience, the ecosystem will remain fragmented, and developers will continue to spend valuable time navigating it.

My Journey from Uno to Avalonia

TL;DR: After evaluating Uno, MAUI, and Avalonia, I chose Avalonia because its packaging, UI libraries, documentation, and cross‑platform performance win out for my project.

1. Why I Even Considered Uno

• I was impressed with Platform (the .NET UI platform).
• If Avalonia hadn’t worked out, Uno would have been my fallback.

2. The Turning Point – Avalonia’s New Packaging Solution

“This was like Xcode Cloud, but for .NET.
You can tell an AI assistant: ‘Package my Avalonia app for macOS as a signed DMG,’ and two minutes later you have a production‑ready, signed application. No certificate wrangling. No build scripts. No wasted afternoons.”

• Key kicker: Build and sign macOS DMG files from Windows – something traditionally impossible with conventional tooling.

3. First Hands‑On with Avalonia

• Started a quick POC with two screens:
  1. Login screen
  2. Main UI showing connected Ditto SDK peers

Results:

• Documentation is clear, comprehensive, and full of good examples.
• Controls behaved as expected.
• Initial UI looked plain, but theming options were available.

4. Theming & UI Libraries

5. Performance Observations

• Uno vs. Avalonia: No massive performance gap; both render quickly on Windows, macOS, and Linux.
• Memory usage: Avalonia seemed slightly better.
• Overall: Consistent, responsive performance across all target platforms.

6. Exciting Roadmap Items for Avalonia

1. Impeller Rendering Engine

   • Originally built by Google for Flutter.
   • GPU‑first, delivering smoother frame rates, lower VRAM usage, and more predictable performance.
   • Avalonia will offer multiple back‑ends (SkiaSharp remains stable), letting developers choose what fits their needs.

2. Avalonia as the Rendering Layer for MAUI on Linux

   • Microsoft’s own MAUI now depends on Avalonia for Linux support – a huge validation of Avalonia’s technical foundation.

7. Why I Ultimately Picked Avalonia

• SukiUI transformation – professional look with minimal effort.
• Documentation – comprehensive, clear, and full of examples.
• Community – active, helpful, quick responses.
• DevTools & Parcel – DevTools are solid (Uno’s designer tools are a bit nicer, but Parcel’s packaging & signing automation outweighs that).
• Cost – subscription is affordable, even for small teams, and eliminates signing/packaging headaches.
• Cross‑platform consistency – Windows, macOS, and Linux all perform well; no Mac Catalyst compromises or platform‑specific jank.
• Productivity – moved from proof‑of‑concept to feature development quickly thanks to docs and examples.

8. A Nod to Uno Platform

• Uno’s developer tooling is industry‑leading; the team clearly cares about developers.
• If you’re heavily invested in the Microsoft ecosystem or need specific Uno features, it remains a solid choice.

9. Why MAUI Isn’t My Recommendation (for serious desktop apps)

• macOS performance: Poor.
• Linux support: Essentially non‑existent.
• Overall polish: Rough edges suggest it’s not production‑ready yet.

Having been a .NET developer for three decades, I’ve seen this pattern before. Microsoft isn’t investing enough in MAUI, while smaller companies like Uno and Avalonia are delivering better solutions.

10. Final Thoughts

• Avalonia works today. I’m not waiting for Microsoft’s next pivot.
• I’m excited to finish my app over the holiday break.
• Avalonia has proven to be fast, stable, and genuinely cross‑platform.
• The documentation is excellent, the community is strong, and the ecosystem (e.g., SukiUI, Parcel) makes development a joy.

If you’re evaluating .NET UI frameworks for a desktop‑first, cross‑platform app, give Avalonia a serious look – especially if you value automated packaging, a thriving component ecosystem, and a roadmap that embraces modern GPU‑first rendering.

The tooling removes the pain points that have plagued .NET desktop development for years.

After 30 years of .NET development—through Windows Forms, WPF, Silverlight, UWP, Xamarin, and MAUI—I’ve finally found a framework I can trust for the long term. It’s not from Microsoft, and maybe that’s exactly why it works.

If you’re building cross‑platform .NET applications, give Avalonia a serious look. It’s what MAUI should have been.