.NET MAUI in 2026: The Latest Updates and What Developers Should Know

The .NET MAUI ecosystem continues to evolve rapidly, and 2026 has brought several important changes for developers building cross-platform applications with .NET.

From the continued evolution of .NET 10, improvements across Android and iOS, XAML source generation, better platform integration, and the upcoming .NET 11 development cycle, .NET MAUI is moving toward a more mature and streamlined cross-platform development experience.

For developers who have been working with Xamarin, .NET MAUI, or earlier versions of .NET, this is an important time to understand where the ecosystem is heading.

.NET MAUI and .NET 10

One of the biggest developments is the continued adoption of .NET MAUI with .NET 10.

.NET 10 focuses heavily on product quality, platform integration, performance, and developer experience. Microsoft has introduced improvements across controls, XAML, Shell, diagnostics, Android, iOS, and other supported platforms.

.NET 10 is also an LTS release of .NET, giving organizations a longer support window for applications built on the platform.

For enterprise applications, this makes .NET 10 particularly interesting as a foundation for new MAUI projects and modernization of existing applications.

1. Better .NET Aspire Integration

One of the interesting additions in .NET 10 is integration with .NET Aspire.

A .NET MAUI project can now be connected to an Aspire service-defaults project. This can provide capabilities such as:

• OpenTelemetry metrics
• Distributed tracing
• Service discovery
• HttpClient service discovery integration

This is particularly useful for applications that communicate with multiple backend services.

For example, a mobile application might communicate with:

.NET MAUI App
      |
      +---- Authentication API
      |
      +---- Customer API
      |
      +---- Notification Service
      |
      +---- AI Service
      |
      +---- Telemetry

Aspire can help bring these distributed application components into a more consistent development and observability experience.

2. XAML Source Generation

XAML is also receiving significant attention.

.NET MAUI 10 introduces a XAML source generator that generates strongly typed code at compile time.

This can improve:

• Build performance
• Tooling
• IntelliSense
• Runtime overhead
• Debugging experience

Source generation can be enabled through the project file:

<PropertyGroup>
    <MauiXamlInflator>SourceGen</MauiXamlInflator>
</PropertyGroup>

This represents an important direction for XAML-based development: moving more work from runtime to compile time.

3. Cleaner XAML Namespaces

.NET MAUI 10 also introduces improvements around XML namespaces.

Developers who have worked with large MAUI applications know how much namespace declarations can accumulate at the top of XAML files.

.NET 10 introduces global and implicit XML namespace capabilities that can significantly reduce this boilerplate.

Instead of repeatedly declaring multiple namespaces, applications can define shared namespaces at the assembly/project level.

This can make large XAML applications considerably easier to maintain.

4. CollectionView and CarouselView Improvements

CollectionView and CarouselView received important improvements in .NET 9, and the newer handlers introduced there are now the default in .NET 10.

These handlers were designed to improve performance and stability on iOS and Mac Catalyst.

For applications that rely heavily on:

• Product lists
• Customer lists
• Dashboards
• Chat interfaces
• Image galleries
• Carousels

these changes are particularly relevant.

5. MessagingCenter Is Now Internal

Another important migration point is MessagingCenter.

In .NET MAUI 10, MessagingCenter has been made internal.

For applications that still depend on MessagingCenter, Microsoft recommends moving toward alternatives such as WeakReferenceMessenger from CommunityToolkit.Mvvm.

For example:

WeakReferenceMessenger.Default.Send(
    new CustomerSelectedMessage(customer));

This is part of the broader evolution of MAUI applications toward stronger, more maintainable messaging patterns.

6. Modern Async APIs

.NET MAUI 10 continues the move toward asynchronous APIs.

Several APIs that previously used synchronous-looking method names have been replaced or deprecated in favor of explicit asynchronous APIs.

For example:

await page.DisplayAlertAsync(
    "Information",
    "Operation completed",
    "OK");

instead of relying on the older:

await page.DisplayAlert(...);

Similarly, animation APIs have moved toward explicit Async naming.

This makes asynchronous behavior clearer and aligns MAUI APIs more closely with modern .NET development practices.

7. SafeArea Improvements

Safe-area handling has historically been an area where cross-platform applications could require platform-specific adjustments.

.NET MAUI 10 introduces improved SafeArea handling through SafeAreaEdges.

This provides more granular control over how layouts interact with areas such as:

• iOS notches
• Home indicators
• Status bars
• Navigation areas
• Edge-to-edge layouts

The property can be applied to layouts, ContentPage, ContentView, Border, ScrollView, and other controls.

This is especially useful when creating modern edge-to-edge mobile interfaces.

Android Gets Major Updates

Android is one of the areas where the .NET 10 ecosystem has received substantial updates.

Android API 36

.NET 10 supports Android API 36, corresponding to Android 16.

For net10.0-android, API 36 is the default target platform in .NET 10.

Microsoft also recommends API 24 as the default minimum supported Android API for new projects, although API 21 remains technically supported.

This is important for developers maintaining older MAUI applications.

A project that previously looked like:

<TargetFramework>net8.0-android</TargetFramework>

may eventually move toward:

<TargetFramework>net10.0-android</TargetFramework>

But upgrading the target framework is only one part of the migration.

Developers also need to review:

• Android libraries
• NuGet packages
• Native bindings
• Permissions
• Background services
• Notifications
• Foreground services
• Manifest configuration
• AOT/trimming configuration
• Store requirements

JDK 21 Support

.NET for Android in .NET 10 also supports JDK 21.

This is an important change for modern Android development environments and CI/CD systems.

Build machines therefore need to be reviewed when migrating older MAUI projects.

For teams using CI services such as GitHub Actions, Azure DevOps, Codemagic, or other hosted build systems, the Android SDK and JDK versions should be treated as part of the application's build configuration rather than as an afterthought.

Experimental CoreCLR on Android

.NET 10 also introduces experimental support for running Android applications using CoreCLR instead of Mono.

This can be enabled with:

<PropertyGroup
    Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">

    <UseMonoRuntime>false</UseMonoRuntime>

</PropertyGroup>

However, this is still experimental and isn't intended for production applications according to the current Microsoft documentation.

Application size, debugging, and runtime diagnostics still have limitations.

This is nevertheless an interesting development because it shows the direction of the broader .NET runtime strategy.

iOS and Mac Catalyst

.NET MAUI continues to evolve alongside Apple's platform changes.

.NET 10 includes updates for iOS, tvOS, Mac Catalyst, and macOS.

One particularly important area is compatibility with newer Apple SDK and Xcode versions.

The MAUI ecosystem is closely tied to Apple's development toolchain, meaning that upgrading a MAUI application can involve more than simply changing the .NET version.

Developers need to consider:

.NET SDK
   ↓
.NET MAUI workload
   ↓
Xcode
   ↓
iOS SDK
   ↓
Apple signing
   ↓
App Store requirements

This dependency chain is one of the reasons why MAUI support differs somewhat from the normal .NET support lifecycle.

.NET MAUI Is Moving Toward .NET 11

While .NET 10 is the major production platform for current MAUI applications, the next generation is already under development.

.NET 11 is bringing another set of changes to the MAUI ecosystem.

One of the most significant developments is the move toward CoreCLR as the default runtime for .NET 11 MAUI applications.

According to the current Microsoft documentation, CoreCLR became the default runtime for .NET 11 applications during the preview cycle, while NativeAOT is available as an opt-in publishing alternative.

This represents a significant architectural direction for .NET MAUI.

Testing Is Also Improving

Another interesting development in .NET 11 is improved testing support.

New test project templates are being introduced for:

• Android
• iOS
• tvOS
• macOS
• Mac Catalyst

These projects can be executed using:

dotnet test

This is particularly interesting for teams that want to bring more automated testing into their cross-platform mobile development pipelines.

What Does This Mean for Existing Xamarin Developers?

For developers coming from Xamarin.Forms, the transition has already been underway for several years.

The ecosystem has moved roughly through:

Xamarin.Forms
      ↓
.NET MAUI
      ↓
.NET 7
      ↓
.NET 8
      ↓
.NET 9
      ↓
.NET 10
      ↓
.NET 11

The important point is that modern MAUI development is no longer simply "Xamarin.Forms with a new name."

The platform is increasingly integrated with modern .NET capabilities.

Developers should therefore think about modernization in terms of:

• Modern .NET
• Modern C#
• Dependency injection
• Source generation
• Native platform APIs
• Observability
• Automated testing
• Cloud/backend integration
• CI/CD
• Trimming and AOT
• Platform-specific capabilities

rather than simply replacing Xamarin namespaces.

Should Existing MAUI Applications Be Upgraded?

There is no universal answer.

Every application has different dependencies and platform requirements.

Before upgrading a production application, it is useful to evaluate:

Application

• Current .NET version
• MAUI workload version
• Target platforms
• Minimum OS versions
• Native dependencies

Android

• Android API level
• JDK version
• Android Gradle/build dependencies
• Foreground services
• Notification behavior
• Play Store requirements

iOS

• Xcode version
• iOS SDK
• Provisioning profiles
• Certificates
• Native bindings

Libraries

• NuGet compatibility
• CommunityToolkit packages
• Third-party controls
• Native SDKs
• Custom bindings

Build Pipeline

• CI image
• .NET SDK
• Android SDK
• JDK
• Xcode
• Signing configuration

A successful MAUI migration is therefore more than changing:

<TargetFramework>net8.0</TargetFramework>

to:

<TargetFramework>net10.0</TargetFramework>

The Bigger Picture

The most interesting aspect of the current .NET MAUI evolution is that the ecosystem is becoming more connected to the broader .NET platform.

We can see this in several areas:

.NET Aspire

Distributed application development and observability.

OpenTelemetry

Better application telemetry and diagnostics.

XAML Source Generation

More compile-time processing.

CoreCLR

Greater runtime alignment across .NET platforms.

NativeAOT

More options for optimized application deployment.

Modern Android APIs

Better alignment with the current Android ecosystem.

Modern Apple SDKs

Continuous integration with Apple's platform evolution.

Automated Testing

Better support for device and platform testing.

These aren't isolated features. Together, they show a broader direction for the platform.

What MAUI Developers Should Focus on Next

For developers building MAUI applications today, I would recommend keeping an eye on these areas:

1. Learn modern .NET

MAUI development is increasingly becoming regular .NET development with platform-specific capabilities.

2. Understand platform APIs

Cross-platform UI doesn't mean every platform behaves identically.

Understanding Android and iOS fundamentals remains extremely valuable.

3. Embrace source generation

Compile-time approaches are becoming increasingly important across the .NET ecosystem.

4. Improve observability

OpenTelemetry and Aspire are making distributed application diagnostics more accessible.

5. Prepare for CoreCLR

The transition toward CoreCLR is one of the most interesting long-term developments in the MAUI ecosystem.

6. Automate testing

Cross-platform applications need testing across real devices, simulators, and operating-system versions.

7. Keep your dependencies current

MAUI applications are heavily dependent on platform SDKs and third-party libraries. Dependency management should therefore be part of the architecture strategy.

Final Thoughts

.NET MAUI is continuing to evolve from a relatively new cross-platform framework into a broader part of the .NET application development ecosystem.

.NET 10 brings improvements across XAML, controls, SafeArea handling, Android, iOS, Aspire integration, diagnostics, and developer tooling.

At the same time, .NET 11 previews provide an indication of where the platform is heading next, particularly around CoreCLR, testing, and deeper integration with modern .NET capabilities.

For developers already invested in MAUI, the ecosystem is worth watching closely.

The future of cross-platform .NET development isn't just about creating one UI that runs on multiple platforms.

It is increasingly about combining:

.NET + Native Platforms + Cloud + Observability + Modern Tooling + AI-assisted Development

into a single development ecosystem.

And that makes the current period one of the most interesting times to be building with .NET MAUI.

References

• Microsoft — What's new in .NET MAUI for .NET 10
• Microsoft — What's new in .NET 10
• Microsoft — What's new in .NET MAUI for .NET 11
• Microsoft — .NET MAUI documentation

This post reflects the .NET MAUI documentation and development status available in September 2026. Preview features can change before their final release.

By Niladri