Introduction

If you're reading this, you probably got the news. Xamarin support officially ended in May 2024. Your apps still work, but you can't update them forever. Google Play will stop accepting updates for Xamarin apps built with Android 13 or earlier. The App Store has similar restrictions coming.

So now you're stuck with a decision: migrate to .NET MAUI, or jump ship entirely to Flutter, React Native, or something else?

I've been there. I've migrated Xamarin apps to MAUI. I've hit the bugs. I've celebrated the wins. And I've watched developers in our community struggle with this exact question for the past two years.

This isn't a sales pitch for MAUI. This is an honest look at what MAUI actually is in 2025, who should use it, who shouldn't, and what the migration process really looks like. We'll talk about the good parts and the messy parts, because both exist.

By the end of this guide, you'll know exactly what to do with your Xamarin apps.

What Is .NET MAUI? (The 2-Minute Version)

.NET MAUI stands for .NET Multi-platform App UI. It's Microsoft's replacement for Xamarin.Forms, built on .NET 6 and later.

Here's the pitch: write C# and XAML once, run it on Android, iOS, macOS, and Windows. Single project structure instead of Xamarin's multi-project setup. Better performance. Modern architecture.

MAUI launched in May 2022. Early versions were rough. Really rough. But by .NET 8 (November 2023) and especially .NET 9 (November 2024), things got noticeably better.

The framework uses a handler-based architecture instead of Xamarin's renderer system. Handlers are lighter and faster. The single project structure means you manage resources, images, and platform-specific code all in one place.

Sounds good, right? Well, sort of. Let's get into the details.

The Honest Truth About .NET MAUI

I'm going to be straight with you. MAUI has had a rocky journey, and pretending otherwise would be dishonest.

What Developers Are Actually Saying

If you spend any time on Reddit, GitHub, or Stack Overflow, you'll see a mix of opinions. Some developers love MAUI. Others are... less enthusiastic.

Common complaints from real developers:

"It shipped too early." Many devs feel Microsoft pushed MAUI to production before it was ready. Early adopters hit showstopping bugs, incomplete features, and tooling issues.

"The bug count is overwhelming." As of late 2024, the MAUI GitHub repo shows over 1,700 open issues. Some bugs that were reported in 2022 still aren't fixed.

"Microsoft isn't using it themselves." This is a big one. Unlike React Native (used by Facebook, Instagram) or Flutter (used by Google apps), Microsoft doesn't seem to be building major consumer apps with MAUI. That makes developers nervous.

"Visual Studio integration is buggy." Hot reload breaking, debugger issues, Mac build host connectivity problems. These aren't edge cases.

"It takes 80% of time fighting tooling, 20% building features." This quote from a GitHub discussion sums up a lot of frustration.

But Here's the Other Side

Not everyone hates MAUI. There are success stories:

• Enterprise apps are running in production successfully

• Performance in .NET 8/9 is legitimately good

• The dashboard and debugging experience work well when they work

• Teams with existing .NET codebases can reuse a lot of logic

• Desktop support (Windows/Mac) is actually pretty solid

One developer on GitHub put it this way: "MAUI works, and the fact it works at all is a feat of engineering. It saved our team countless hours compared to maintaining separate native apps."

My Take

MAUI in 2022 and 2023? Honestly, it was painful. I wouldn't have recommended it for new projects.

MAUI in 2025? It's usable. Not perfect, but usable. If you're in the Microsoft ecosystem and building certain types of apps, it can work well.

The question isn't "Is MAUI good?" The question is "Is MAUI right for YOUR situation?"

Let's figure that out.

Xamarin vs MAUI: What Actually Changed

If you're coming from Xamarin, here's what's different:

Single Project Structure

Xamarin: You had separate projects for iOS, Android, and shared code. Platform-specific resources lived in platform-specific projects.

MAUI: One project for everything. A Platforms folder has platform-specific code, but resources like images and fonts live in one place.

This is genuinely better. Less project juggling. Easier to manage.

Architecture: Renderers vs Handlers

Xamarin: Used custom renderers to map controls to native UI. These were heavy and complex to customize.

MAUI: Uses handlers. They're lighter, faster, and easier to customize. You can still use Xamarin renderers in MAUI if you need to, but handlers are the future.

Performance

MAUI apps generally start faster and use less memory than Xamarin apps. The compilation to native binaries is more efficient. In real-world testing, MAUI apps often feel snappier.

.NET Version

Xamarin: Built on Mono runtime, an older implementation of .NET Framework.

MAUI: Built on .NET 6/7/8/9, the modern unified .NET platform. You get all the new C# features, better performance, and the latest runtime improvements.

Resources and Images

Xamarin: You needed multiple image resolutions for different devices. Separate files for Android, iOS, etc.

MAUI: Single SVG image for everything. MAUI converts it to the right resolution for each platform automatically.

Development Experience

Xamarin: Needed separate Visual Studio or Xamarin Studio installations. Setup was complex.

MAUI: Integrated into Visual Studio 2022 and VS Code. One-click install with the workload. The setup is cleaner.

Platform Support

Xamarin: iOS, Android, UWP (Universal Windows Platform)

MAUI: iOS, Android, macOS, Windows (via WinUI 3), and Samsung Tizen

So you lose UWP but gain macOS and modern Windows support.

Should You Migrate? Decision Framework

Let's make this practical. Here's how to decide.

Migrate to MAUI If:

You're in the Microsoft ecosystem. Your team knows C#, you use Azure, you have .NET backend services. MAUI lets you share code and expertise.

You need desktop apps too. MAUI's Windows and macOS support is actually good. If you want mobile and desktop from one codebase, MAUI makes sense.

You build enterprise/internal apps. Line-of-business apps, internal tools, B2B applications. MAUI works well here. The rough edges matter less, and Microsoft support matters more.

Your Xamarin app is relatively simple. If you're using standard controls, basic layouts, and not doing anything too custom, migration can be straightforward.

You want to stay in the family. You like Visual Studio. You like XAML. You don't want to learn Dart or JavaScript. That's valid.

Skip MAUI (Consider Alternatives) If:

You're building consumer apps with complex UI. If you need pixel-perfect design, complex animations, or cutting-edge mobile features, Flutter might serve you better.

You have a JavaScript team. If your developers already know React, React Native is a natural fit. Don't fight your team's strengths.

You need a huge ecosystem. React Native and Flutter have way more third-party libraries, components, and community support.

Your app needs bleeding-edge platform features immediately. Flutter and React Native tend to get new iOS/Android features faster than MAUI.

You're sick of Microsoft's track record. Silverlight, Windows Phone, UWP, Xamarin. If you don't trust Microsoft to stick with MAUI long-term, that's a reasonable concern.

The Middle Ground: Wait and See

If you can afford to wait:

• Your Xamarin apps still work

• You have until Google/Apple force the issue (they're extending deadlines)

• MAUI is improving with each .NET release

• Maybe wait for .NET 10 in late 2025

Just know that you're on borrowed time. Eventually, you'll have to make a call.

The Migration Process: What It Actually Involves

Let's say you're migrating. Here's what you're in for.

Step 1: Assessment

Look at your Xamarin.Forms project. What are you using?

• Standard controls? Great, these migrate easily.

• Custom renderers? You'll need to rewrite these as handlers.

• Third-party libraries? Check if MAUI versions exist.

• Platform-specific code? Most of it can move over with minimal changes.

Step 2: Use the Upgrade Assistant

Microsoft has a tool that does a lot of the grunt work:

bash

dotnet tool install -g upgrade-assistant
upgrade-assistant upgrade YourXamarinProject.csproj

This tool:

• Converts project files to the new SDK format

• Updates namespace references

• Identifies incompatible packages

• Migrates most of your XAML

It's not magic. It gets you maybe 70-80% of the way there. You still need to fix things manually.

Step 3: Fix the Namespace Changes

Xamarin.Forms became Microsoft.Maui. You'll need to update using statements:

csharp

// Old Xamarin
using Xamarin.Forms;
using Xamarin.Essentials;

// New MAUI
using Microsoft.Maui;
using Microsoft.Maui.Controls;

The upgrade assistant handles most of this, but you'll catch stragglers.

Step 4: Update Platform-Specific Code

iOS and Android code mostly works the same, but there are changes:

Android:

• MainActivity needs to inherit from MauiAppCompatActivity

• Update Android manifest for new target versions

iOS:

• AppDelegate changes to use MAUI's app lifecycle

• Update Info.plist for iOS 16/17

Step 5: Rewrite Custom Renderers as Handlers

This is where it gets real. If you have custom renderers, you need to convert them.

Xamarin renderer:

csharp

[assembly: ExportRenderer(typeof(CustomEntry), typeof(CustomEntryRenderer))]
public class CustomEntryRenderer : EntryRenderer
{
    protected override void OnElementChanged(ElementChangedEventArgs<Entry> e)
    {
        base.OnElementChanged(e);
        // Custom code here
    }
}

MAUI handler:

csharp

public class CustomEntryHandler : EntryHandler
{
    protected override void ConnectHandler(EditText platformView)
    {
        base.ConnectHandler(platformView);
        // Custom code here
    }
}

It's not a one-to-one mapping. You'll need to rethink some things. Microsoft has migration guides, but expect to spend time here.

Step 6: Update Third-Party Libraries

Check each NuGet package:

• Does a MAUI version exist?

• If not, is there an alternative?

• Can you wait for the maintainer to update?

• Do you need to write your own?

Common libraries like SQLite, JSON.NET, and most major packages have MAUI support. Smaller niche libraries might not.

Step 7: Test Everything

This is not optional. MAUI has bugs. Your migration has bugs. Test on real devices, not just simulators.

• Test all features

• Test on Android and iOS

• Test on different screen sizes

• Test performance

• Test edge cases

Budget extra time for this. You will find issues.

Realistic Timeline

For a medium-sized Xamarin.Forms app:

• Simple app: 2-4 weeks

• Medium complexity: 1-2 months

• Complex app with custom renderers: 2-4 months

Add 50% more time for unexpected issues. Seriously.

MAUI vs Flutter vs React Native

You need to hear this comparison because these are your real alternatives.

When to Choose MAUI

• You're a .NET shop

• You need Windows/macOS desktop support

• You want to reuse existing .NET code

• Your team knows C# and XAML

• You build enterprise apps

When to Choose Flutter

• You want the best cross-platform UI consistency

• Performance and smooth animations are critical

• You're building a consumer-facing app

• You're willing to learn Dart (it's not hard)

• You want a huge ecosystem and community

Flutter pros:

• Fast development with hot reload

• Beautiful, customizable UI

• Great documentation

• Huge package ecosystem

• Google is actually using it in production

Flutter cons:

• Dart is another language to learn

• Apps can be larger in size

• Some platform-specific features need plugins

When to Choose React Native

• Your team already knows JavaScript/TypeScript

• You have existing React web apps (code reuse)

• You want the biggest community and ecosystem

• You need tons of third-party components

• You're comfortable with a more fragmented ecosystem

React Native pros:

• Massive community

• Tons of libraries and components

• JavaScript/TypeScript familiarity

• Good performance for most apps

• Facebook, Instagram, Airbnb built with it

React Native cons:

• Bridge layer can cause performance issues in complex apps

• Fragmented ecosystem (many outdated packages)

• Native module integration can be painful

• UI inconsistencies between platforms

The Brutal Honesty Table

My Honest Recommendation

If you're starting from scratch today and don't have a specific reason to use MAUI (existing .NET code, C# expertise, desktop needs), I'd lean toward Flutter or React Native. They're more mature, have bigger ecosystems, and frankly, you'll have an easier time.

If you're migrating from Xamarin and already deep in .NET, MAUI makes sense. The migration path exists, and you keep your expertise and code.

Common Pitfalls and How to Avoid Them

Real problems people hit when using MAUI:

Pitfall 1: Expecting Xamarin-Level Stability

MAUI is newer. It has more bugs. If you go in expecting Xamarin.Forms stability, you'll be disappointed.

Solution: Budget extra time. Test more. Have fallback plans.

Pitfall 2: Not Using .NET 8 or Later

MAUI on .NET 6 and .NET 7 was rough. .NET 8 brought huge improvements. .NET 9 is even better.

Solution: Use the latest .NET version. Seriously. Don't stick with .NET 6.

Pitfall 3: Fighting the Single Project Structure

Developers try to make MAUI projects look like Xamarin projects. Don't. Embrace the new structure.

Solution: Learn the MAUI way of doing things. It's actually better once you adjust.

Pitfall 4: Ignoring Platform-Specific Code When Needed

Trying to make everything cross-platform when you need platform-specific code leads to hacks.

Solution: Use platform-specific code when it makes sense. MAUI makes this easy with conditional compilation and the Platforms folder.

Pitfall 5: Not Testing on Real Devices

Simulators lie. Especially the iOS simulator.

Solution: Test on actual phones and tablets. Performance, rendering, and behavior can differ wildly.

Pitfall 6: Underestimating Third-Party Library Gaps

Your favorite Xamarin library might not have a MAUI version yet.

Solution: Audit your dependencies early. Find alternatives before you start migrating.

Real-World Examples: Who's Using MAUI Successfully?

Let's talk about actual use cases where MAUI works well.

Enterprise Internal Tools

A logistics company migrated their warehouse management app from Xamarin to MAUI. Used by 500+ employees on tablets and phones. Complex forms, barcode scanning, offline sync.

Result: Migration took 6 weeks. App performs better. Development team is happy with the single project structure.

Healthcare Line-of-Business App

Hospital patient management system. iPad and Android tablets for nurses. Integration with .NET backend APIs. HIPAA compliance requirements.

Result: MAUI worked great. Native performance, good security, seamless backend integration. No complaints from users.

Field Service Application

Technicians use it for work orders, time tracking, equipment management. iOS and Android. Heavy use of device features (camera, GPS, signature capture).

Result: Successful migration. Some issues with custom controls, but overall positive. Team appreciates staying in the .NET ecosystem.

Cross-Platform Desktop App

Financial modeling tool for Windows and macOS. Complex data grids, charts, calculations.

Result: MAUI's desktop support shines here. One codebase for both platforms. Performance is excellent.

Where MAUI Didn't Work Well

A consumer-facing e-commerce app tried MAUI. Heavy animations, complex custom UI, frequent feature updates needed immediately when iOS/Android release new versions.

Result: Team switched to Flutter after 4 months. MAUI wasn't keeping up with their UI needs and platform update requirements.

The State of MAUI in 2025

Let's zoom out and look at where things stand now.

What's Improved

Performance: .NET 8 and 9 brought real performance gains. Startup times are better. Memory usage is lower.

Stability: Fewer crashes. Fewer showstopper bugs. It's not perfect, but it's much better than 2022/2023.

Tooling: Visual Studio integration has improved. Hot reload works more consistently. The debugger is more reliable.

Community: More libraries are available. More tutorials exist. Stack Overflow has more answers.

Documentation: Microsoft has filled in gaps. More examples. Better migration guides.

What Still Needs Work

Bug backlog: Still too many open issues on GitHub. Some have been open for years.

Third-party ecosystem: Still smaller than Flutter or React Native. Gaps in available components.

Fragmentation: Different behavior across platforms. Things that work on Android break on iOS, and vice versa.

Microsoft commitment: Still not seeing major Microsoft products built with MAUI, which is concerning.

The Roadmap Ahead

.NET 10 is coming in November 2025. We can expect:

• More bug fixes (hopefully)

• Performance improvements

• Better tooling

• Enhanced desktop features

• Improved trimming and AOT compilation

Will it be enough? Time will tell.

Making Your Decision: A Practical Checklist

Go through these questions:

About Your App:

• Is it consumer-facing or internal/enterprise?

• Does it need cutting-edge mobile features immediately?

• How complex is the UI? Simple forms or heavy custom design?

• Do you need desktop (Windows/Mac) support?

• What's your timeline for migration or development?

About Your Team:

• Do your developers know C# and .NET?

• Are they comfortable with XAML?

• Do they know JavaScript or Dart?

• How much time can you budget for learning?

• Can you afford to hit bugs and work around them?

About Your Business:

• Are you already in the Microsoft ecosystem?

• Do you have existing .NET backend code to reuse?

• Can you afford to wait if MAUI has issues?

• Do you need long-term support guarantees?

• What's your budget for development and maintenance?

About The Future:

• Do you trust Microsoft to maintain MAUI?

• Can you pivot to another framework if needed?

• Are you okay with a smaller ecosystem?

• Will you need to hire developers later?

Answer these honestly. Your answers will make the decision clearer.

Resources for Learning More

Official Documentation

• .NET MAUI Documentation - Start here

• Migration Guide - Xamarin to MAUI

• .NET MAUI GitHub - Source code, issues, discussions

Community Resources

Reddit:

• r/dotnet - Main .NET community

• r/xamarin - Still active for migration discussions

• Search for "MAUI" to see real experiences

Stack Overflow:

• Tag: maui or .net-maui

• Lots of migration questions answered here

YouTube:

• .NET YouTube channel has official tutorials

• Community creators like James Montemagno post helpful content

GitHub Discussions:

• The MAUI repo discussions are worth reading

• See what issues people are hitting

• See what the team is prioritizing

Comparison Resources

• Flutter comparison whitepaper - Moving to Flutter vs MAUI

• Cross-platform framework surveys - Stack Overflow annual survey

Migration Tools

• Microsoft's Upgrade Assistant

• .NET MAUI Community Toolkit

• Third-party migration services (if budget allows)

Wrapping Up: What I'd Do

If someone asked me today, "Should I migrate my Xamarin app to MAUI?", here's what I'd say:

If you're a .NET shop building enterprise apps: Yes, migrate. MAUI is good enough now, and you need to get off Xamarin anyway. Budget extra time, use .NET 8 or 9, and you'll be fine.

If you're building consumer apps with complex UI: Think hard about Flutter. It'll give you a better development experience and more design control.

If your team is JavaScript-heavy: React Native makes more sense. Don't fight your team's strengths.

If you're starting a brand new project: Unless you have a specific reason to use MAUI (existing .NET code, C# expertise, desktop requirements), I'd pick Flutter. It's more mature and has a bigger ecosystem.

If you can wait: Wait for .NET 10 in late 2025. Let MAUI mature more. But have a deadline. You can't wait forever.

The honest truth is that MAUI works for certain scenarios. It's not the best choice for everyone, but it's a viable option if your situation aligns with its strengths.

Xamarin is dead. MAUI is the Microsoft path forward. Whether that's the right path for you depends on your specific context.

Whatever you decide, make an informed choice. Don't just follow the hype. Look at your team, your app, your business, and choose the tool that actually solves your problems.

Good luck with your migration, whatever you choose.

---

Have you migrated from Xamarin to MAUI? If you're still deciding, what questions do you have? Let's discuss.