What's New in .NET MAUI 10: A Comprehensive Guide to the Latest Features

Introduction: Quality Over Features

Microsoft's .NET MAUI 10 release represents a strategic shift in the framework's evolution. Released as part of .NET 10—the latest Long-Term Support (LTS) version with three years of support—this update prioritizes quality, stability, and developer experience over flashy new features. If you've been developing cross-platform applications with .NET MAUI, this release brings crucial improvements that will make your development workflow smoother and your apps more reliable.

As someone who has worked extensively with cross-platform frameworks, I appreciate Microsoft's focus on addressing pain points that developers encounter in real-world scenarios. Let's dive into what makes .NET MAUI 10 a significant upgrade for mobile and desktop application development.

Quality-First Approach and Distribution Model

The overarching theme of .NET MAUI 10 is product quality improvement. Microsoft listened to community feedback and invested heavily in fixing bugs, improving performance, and enhancing the developer experience. This isn't just marketing speak—the changes run deep throughout the framework.

New Distribution Model

One of the most practical changes is how .NET MAUI is distributed. Starting with .NET 10, MAUI ships as a .NET workload with multiple NuGet packages. This architectural change enables you to:

• Pin your projects to specific MAUI versions independently of your .NET SDK version
• Test preview or experimental builds without affecting your entire development environment
• Upgrade MAUI components incrementally rather than all-or-nothing updates
• Better manage dependencies in enterprise environments with strict version control requirements

This flexibility is particularly valuable for teams maintaining multiple projects at different stages of the development lifecycle. You can now confidently upgrade one project while keeping others on a proven stable version.

HybridWebView: Bridging Web and Native

HybridWebView continues to mature as one of MAUI's most powerful components for developers building apps that blend web technologies with native capabilities. .NET 10 brings several enhancements that make it even more versatile.

New InvokeJavaScriptAsync Overload

The new InvokeJavaScriptAsync overload allows you to invoke JavaScript methods without specifying return type information. This is particularly useful for fire-and-forget scenarios where you're triggering UI updates or analytics events from your .NET code:

// Previous approach - had to specify return type even for void methods
await hybridWebView.InvokeJavaScriptAsync<object>("updateNotificationBadge", badgeCount);

// New approach - cleaner for methods without returns
await hybridWebView.InvokeJavaScriptAsync("updateNotificationBadge", badgeCount);

Platform-Specific Initialization

Two new events—WebViewInitializing and WebViewInitialized—give you precise control over the native web view configuration. This is crucial when you need to customize settings that aren't exposed through the MAUI abstraction layer:

hybridWebView.WebViewInitializing += (sender, args) =>
{
#if ANDROID
    args.Settings.DomStorageEnabled = true;
    args.Settings.DatabaseEnabled = true;
#elif IOS || MACCATALYST
    args.Configuration.Preferences.SetValueForKey(
        NSNumber.FromBoolean(true), 
        new NSString("allowFileAccessFromFileURLs"));
#endif
};

Web Request Interception

One of the most anticipated features is the ability to intercept and respond to web requests made from both BlazorWebView and HybridWebView. This opens up powerful scenarios like custom protocol handling, offline data synchronization, and API mocking for testing:

hybridWebView.WebRequestReceived += (sender, args) =>
{
    if (args.Request.Url.StartsWith("app://api/"))
    {
        // Handle API requests natively
        var response = await _apiService.HandleRequest(args.Request);
        args.Response = response;
    }
};

Improved Error Handling

JavaScript exceptions are now automatically propagated to .NET and re-thrown as .NET exceptions. This dramatically improves debugging by surfacing JavaScript errors in your C# catch blocks and logging infrastructure, making it easier to track down issues in hybrid scenarios.

SafeAreaEdges: Granular Control Over Layout

Modern mobile devices have notches, camera cutouts, curved screens, and gesture bars that create "unsafe areas" where content might be obscured. .NET MAUI 10 introduces refined SafeAreaEdges management that gives you precise control over how your content relates to these system UI elements.

Understanding SafeAreaEdges Values

The enhanced SafeAreaEdges enum provides these options:

• None – Enables true edge-to-edge content, ignoring all safe area insets. Perfect for immersive experiences like photo viewers or games.
• SoftInput – Only adds padding for the on-screen keyboard, allowing your content to extend under status bars and navigation bars while still keeping input fields visible when the keyboard appears.
• Container – Respects system UI elements like status bars, navigation bars, and device notches. This is the traditional behavior most apps need.
• Default – Uses platform-specific defaults, which may vary between iOS and Android.
• All – Applies all safe area insets comprehensively.

Breaking Change: Android ContentPage Default

An important breaking change to note: ContentPage on Android now defaults to SafeAreaEdges.None instead of SafeAreaEdges.Container. This change aligns Android behavior with iOS and enables true edge-to-edge layouts by default.

If you're upgrading existing apps and notice layout issues, you may need to explicitly set:

<ContentPage SafeAreaEdges="Container">
    <!-- Your content -->
</ContentPage>

SafeAreaEdges can now be applied to Layout, ContentView, ContentPage, Border, and ScrollView, giving you fine-grained control at multiple levels of your UI hierarchy.

Android Updates: API 36 and CoreCLR

.NET MAUI 10 targets Android API 36 (Baklava Beta 3) by default when you use net10.0-android as your target framework. This ensures your apps can leverage the latest Android capabilities and meet Google Play Store requirements.

Experimental CoreCLR Runtime Support

One of the most interesting experimental features is the ability to run Android apps on the CoreCLR runtime instead of Mono. While not yet production-ready (it currently produces larger app sizes), this represents Microsoft's long-term vision for runtime unification:

<PropertyGroup>
    <UseMonoRuntime>false</UseMonoRuntime>
</PropertyGroup>

This experimental feature is worth watching if you're interested in the future direction of .NET on mobile platforms.

Editor and Entry Improvements

On Android, the Editor and Entry controls now use MauiAppCompatEditText instead of AppCompatEditText. This change adds native support for the SelectionChanged event, which is crucial for implementing features like auto-complete, formatting helpers, and character count indicators:

myEntry.SelectionChanged += (sender, args) =>
{
    // Track cursor position for auto-complete
    var cursorPosition = args.NewSelection.Start;
    UpdateAutoCompleteSuggestions(cursorPosition);
};

Enhanced Development Workflow

.NET 10 brings dotnet run support to Android, simplifying command-line workflows:

# Run on connected device
dotnet run -p:AdbTarget=-d

# Run on emulator
dotnet run -p:AdbTarget=-e

# Run on specific target
dotnet run -p:AdbTarget=-s emulator-5554

Other developer experience improvements include faster CLI builds using System.IO.Compression for .apk creation, design-time builds that skip aapt2 by parsing .aar files directly, and JDK 21 support.

iOS and Mac Catalyst Enhancements

Modal Popovers

iOS and Mac Catalyst apps can now display modal pages as popovers, perfect for iPad apps that need to maintain context while showing secondary content:

var detailPage = new DetailPage();
detailPage.ModalPopoverSourceView = sourceButton;
detailPage.ModalPopoverRect = new Rect(0, 0, 200, 44);
await Navigation.PushModalAsync(detailPage);

Secondary Toolbar Items

Toolbar items with Order="Secondary" are now grouped into an elegant pull-down menu on iOS and Mac Catalyst, providing a cleaner navigation bar while still keeping secondary actions accessible:

<ContentPage.ToolbarItems>
    <ToolbarItem Text="Primary Action" Order="Primary" />
    <ToolbarItem Text="Settings" Order="Secondary" />
    <ToolbarItem Text="About" Order="Secondary" />
</ContentPage.ToolbarItems>

Build and Deployment Improvements

Several improvements streamline iOS development:

• Xcode 16 Beta 4 support with net10.0-ios16 targeting
• Trimmer enabled by default for arm64 simulator and device builds, reducing app size
• Trimmer warnings now enabled (can be suppressed via MSBuild properties)
• iOS binding projects can now build on Windows without requiring a Mac connection

XAML Enhancements: Source Generator and Implicit Namespaces

XAML Source Generator

The new XAML source generator creates strongly-typed code at compile time rather than relying on runtime reflection. This improves build performance and provides better tooling support. Enable it in your project file:

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

The benefits include faster builds, better IntelliSense, and earlier error detection during compilation rather than at runtime.

Implicit Global XML Namespaces

XAML files traditionally required verbose namespace declarations at the top of every file. .NET MAUI 10 introduces implicit global namespace injection:

<!-- Before: Lots of boilerplate -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:local="clr-namespace:MyApp.Views"
             xmlns:vm="clr-namespace:MyApp.ViewModels">

<!-- After: Clean and minimal -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/maui/global">
    <!-- Automatically includes common namespaces -->
</ContentPage>

With an opt-in feature switch, even xmlns and xmlns:x can become implicit, eliminating virtually all namespace boilerplate from your XAML files.

Control Updates and Deprecations

Enhanced Controls

Several controls received valuable improvements:

• DatePicker and TimePicker now support nullable selection, perfect for optional date fields in forms
• SearchBar added SearchIconColor and ReturnType properties for better customization
• Switch gained an OffColor property to customize both states
• Picker now has a programmatic Open/Close API for better control flow
• RefreshView added IsRefreshEnabled to conditionally disable pull-to-refresh

Deprecated Features

To streamline the framework, several legacy controls and APIs have been deprecated:

• ListView and related cells (EntryCell, ImageCell, SwitchCell, TextCell, ViewCell) – Use CollectionView instead for better performance
• TableView – Replace with CollectionView for tabular data
• Page.IsBusy – Use ActivityIndicator directly for loading states
• Synchronous animation methods (FadeTo, ScaleTo, TranslateTo, etc.) – Use async variants (FadeToAsync, ScaleToAsync, TranslateToAsync)
• DisplayAlert and DisplayActionSheet – Use async methods DisplayAlertAsync and DisplayActionSheetAsync

Breaking Change: MessagingCenter

The MessagingCenter class has been made internal. Microsoft recommends migrating to WeakReferenceMessenger from the CommunityToolkit.Mvvm NuGet package, which provides better performance and prevents memory leaks:

// Old approach (no longer available)
MessagingCenter.Send(this, "UpdateData", data);

// New approach
WeakReferenceMessenger.Default.Send(new UpdateDataMessage(data));

Performance Monitoring and Diagnostics

.NET MAUI 10 introduces comprehensive metrics tracking that integrates with .NET's telemetry infrastructure. The framework now exposes an ActivitySource named "Microsoft.Maui" for distributed tracing and records detailed layout metrics:

• maui.layout.measure_count – Number of measure operations
• maui.layout.measure_duration – Time spent in measure operations
• maui.layout.arrange_count – Number of arrange operations
• maui.layout.arrange_duration – Time spent in arrange operations

These metrics integrate seamlessly with Application Insights, Prometheus, and other observability platforms, helping you identify layout performance bottlenecks in production apps.

Device Integration Improvements

Several platform integration APIs received useful enhancements:

• MediaPicker now automatically handles EXIF rotation and preserves metadata, plus PickMultipleAsync supports compression via MaximumWidth and MaximumHeight
• Geolocation added a read-only IsEnabled property to check location services status
• TextToSpeech now supports Rate property in SpeechOptions for controlling speech speed
• WebAuthenticator's AuthenticateAsync accepts a CancellationToken for better async operation control
• Vibration and HapticFeedback expose IsSupported to check device capabilities before attempting to use these features

Migration Considerations

When upgrading to .NET MAUI 10, keep these migration points in mind:

Android SafeAreaEdges

Check your Android layouts and add SafeAreaEdges="Container" to ContentPages if you notice content extending under system bars unexpectedly.

MessagingCenter Replacement

Add the CommunityToolkit.Mvvm NuGet package and replace MessagingCenter usage with WeakReferenceMessenger throughout your codebase.

Async Method Updates

Update synchronous animation and popup methods to their async counterparts. This is typically a straightforward find-and-replace with an added "Async" suffix and "await" keyword.

Deprecated Control Migration

Plan to migrate from ListView to CollectionView if you haven't already. CollectionView offers better performance, more flexibility, and will receive ongoing support and improvements.

Conclusion: A Solid Foundation for Cross-Platform Development

.NET MAUI 10's focus on quality over features is exactly what the framework needed at this stage of maturity. The improvements to HybridWebView make it a compelling choice for teams with web development expertise who want to leverage those skills in mobile apps. The refined SafeAreaEdges management gives designers and developers the control they need to create modern, edge-to-edge interfaces. Android and iOS enhancements keep the platform competitive with native development tools.

The three-year LTS support makes .NET 10 an excellent foundation for enterprise applications that need long-term stability. The new distribution model provides the flexibility to adopt updates at your own pace, while the deprecated features give clear migration paths for legacy code.

Key Takeaways

• .NET 10 is an LTS release with three years of support, making it ideal for enterprise applications
• HybridWebView improvements enable sophisticated web-native integration scenarios
• SafeAreaEdges refinements provide precise control over modern device layouts
• Android API 36 support and experimental CoreCLR runtime show Microsoft's commitment to the platform
• XAML enhancements reduce boilerplate and improve build performance
• Comprehensive deprecations provide clear migration paths toward modern patterns
• Enhanced diagnostics and metrics support production observability

At MallitLabs, we're excited about .NET MAUI 10's improvements and the maturity they represent for cross-platform development. Whether you're building consumer mobile apps, enterprise line-of-business applications, or hybrid web-native experiences, .NET MAUI 10 provides a robust, performant foundation that will serve you well for years to come.

If you're considering .NET MAUI for your next cross-platform project or need help migrating existing Xamarin.Forms applications, the MallitLabs team has the expertise to guide you through the process and build high-quality applications that your users will love.