Starting with .NET 11 Preview 4, .NET MAUI apps targeting Android, iOS, and Mac Catalyst will run on CoreCLR by default, Microsoft announced on May 13, 2026. The shift replaces Mono, the long-time default mobile runtime, with the same high-performance runtime that powers server and desktop .NET workloads. This move unifies the .NET platform and opens the door for advanced features like NativeAOT on mobile.

The change has been years in the making. Since .NET 8, developers could opt into CoreCLR for mobile via a project property, but Mono remained the safe, stable default. With .NET 11, CoreCLR becomes the standard for new projects. Existing apps can keep using Mono for compatibility, but Microsoft strongly encourages migrating to take advantage of better performance, smaller binaries, and faster startup times.

The Switch to CoreCLR: What’s Changing

For years, .NET MAUI (and Xamarin before it) relied on Mono for Android, iOS, and macOS apps. Mono is a mature, cross-platform .NET runtime optimized for constrained environments, but it lacks many of the performance improvements and modern features of CoreCLR. CoreCLR, the runtime behind ASP.NET Core, Windows desktop apps, and all server-side .NET workloads, brings just-in-time (JIT) compilation, better garbage collection, and full access to the latest .NET libraries.

In .NET 11 Preview 4, the default $(UseMauiCoreCLR) project property flips from false to true for mobile targets. Developers who create a new .NET MAUI project from the dotnet new template or Visual Studio will automatically get CoreCLR. Existing projects that upgrade to .NET 11 Preview 4 will need to explicitly set the flag to false if they wish to stay on Mono, though this is not recommended for long-term support.

Why CoreCLR?

The push toward CoreCLR is driven by three key goals: performance, consistency, and access to modern .NET features.

Performance: CoreCLR’s tiered JIT and Region-based GC can significantly reduce allocation overhead and improve throughput. Microsoft internal benchmarks show CPU-bound tasks running 20–40% faster on CoreCLR compared to Mono on identical mobile hardware. UI-heavy apps see smoother scrolling and faster response times because the runtime better optimizes hot paths.

Consistency: With CoreCLR everywhere, the same code runs identically on Android, iOS, Windows, and macOS. This simplifies debugging and reduces platform-specific bugs. Developers no longer need to maintain separate code paths or conditional compilation for Mono-only APIs.

Modern Features: CoreCLR unlocks NativeAOT (ahead-of-time compilation) for mobile, previously only available for console apps and native libraries. NativeAOT compiles .NET code directly into native machine code before deployment, eliminating JIT overhead entirely. The result is dramatically faster startup times (up to 50% faster cold start) and smaller app sizes—critical wins for mobile.

Performance and Compatibility Benefits

Early adopters who tested CoreCLR on mobile with .NET 8 and .NET 9 reported measurable gains. A reference e-commerce app compiled with CoreCLR and NativeAOT showed a 30% reduction in memory usage and a 40% decrease in time-to-interaction on mid-range Android devices. iOS apps benefited from Swift interop improvements tied to CoreCLR’s unified type system.

Compatibility remains a top priority. Microsoft claims 98% of Mono-based .NET MAUI apps should run unchanged on CoreCLR. The main breaking changes involve reflection-heavy code, dynamic code generation (which is prohibited in NativeAOT builds), and certain third-party libraries that embedded Mono-specific JIT intrinsics. The .NET team has published a migration guide and a Roslyn analyzer to detect potential issues.

For libraries and plugins, maintainers are urged to add CoreCLR and NativeAOT compatibility targets. Popular packages like CommunityToolkit.Maui and SkiaSharp have already shipped compatible versions.

Impact on App Size and Startup Time

One of the biggest criticisms of .NET MAUI compared to native SDKs has been larger app bundles and slower cold starts. Mono’s interpreter and JIT require shipping the Mono runtime (~3–5 MB) and cause a pause during first method compilation. CoreCLR with NativeAOT strips away the JIT and runtime overhead: the compiler links only required framework code, yielding binaries as small as 15 MB for a minimal app, compared to 30–40 MB with Mono.

Startup time improvements are equally drastic. In Microsoft’s tests, a “Hello World” MAUI app on a Pixel 7a launched in 0.4 seconds with NativeAOT versus 1.1 seconds with Mono JIT. Complex apps see similar proportional gains, though the exact delta depends on how much code runs at startup.

NativeAOT and Ahead-of-Time Compilation

NativeAOT is the headline feature of the CoreCLR transition. It compiles the entire app—including the BCL, MAUI framework, and user code—into a single native executable. This has several benefits:

  • No JIT startup delays. The app is ready to run the moment the OS loads it.
  • Smaller memory footprint. There is no JIT metadata or runtime compilation cache.
  • Better security. Without a JIT, dynamic code injection techniques become much harder, reducing the attack surface.
  • App Store compliance. Apple’s App Store already requires bitcode-free native binaries, and NativeAOT aligns perfectly with Google Play’s upcoming policies on memory-tagged extensions.

Developers must be mindful of NativeAOT’s limitations: runtime code generation (Reflection.Emit, Assembly.Load) is not supported. Workarounds exist for common patterns, like using source generators instead of runtime reflection for serialization and DI.

Migration for Developers

The upgrade path for existing projects is straightforward. After updating to .NET 11 Preview 4 and the corresponding MAUI workload, developers can add the following to their .csproj:

<PropertyGroup>
  <UseMauiCoreCLR>true</UseMauiCoreCLR>
  <PublishAot>true</PublishAot>   <!-- to enable NativeAOT -->
</PropertyGroup>

The PublishAot flag is optional but recommended for production builds. Without it, CoreCLR still brings JIT performance improvements but without the size and startup benefits.

Microsoft provides a step-by-step migration document covering:
- Running the compatibility analyzer.
- Updating reflection-heavy code (JSON serializers, ORMs, DI containers).
- Trimming and AOT annotations.
- Testing on real devices.

The team also recommends enabling the ILLink trimmer aggressively and fixing all trim warnings before switching to CoreCLR, as the AOT compiler is stricter about unreachable code.

Community Reaction and Concerns

Reaction across GitHub, Reddit, and the .NET MAUI Discord has been largely positive. Developers have long requested a single unified runtime, and the promise of smaller, faster apps resonates. “Finally, we can stop explaining why MAUI apps are bigger than Flutter,” wrote one developer on the MAUI GitHub discussion thread.

However, some concerns linger:

  • Debugging experience: Early adopters note that debugging NativeAOT apps on Android can be slower because the debugger must map native code back to managed symbols. Microsoft promises improvements with the new debug engine in Visual Studio 2026.
  • Library ecosystem gaps: Many NuGet packages still assume Mono or full JIT capabilities. While big players have updated, long-tail dependencies may lag.
  • Platform-specific APIs: Certain platform interop scenarios (like calling Java or Objective-C code) previously relied on Mono embedding APIs. These have been reimplemented over CoreCLR, but community testing will reveal edge cases.

Microsoft has committed to keeping Mono as an optional fallback until .NET 12 to give the ecosystem time to adapt.

The Road Ahead

With CoreCLR becoming the default, the .NET MAUI team plans to accelerate innovation that was previously gated by Mono limitations. Upcoming improvements include:

  • Better support for background services on Android, leveraging CoreCLR’s efficient GC.
  • WebAssembly hybrid apps that share the same runtime as client-side Blazor.
  • Unified profiling and diagnostics across all platforms, so tools like dotnet-trace and PerfView work on mobile just as they do on desktop.

.NET 11 itself is scheduled for general availability in November 2026. The Preview 4 release includes CoreCLR by default, along with .NET MAUI performance improvements for CollectionView and navigation. Developers can download the preview from the .NET website and start testing today.

The move to CoreCLR is more than a runtime swap—it’s a statement that .NET MAUI is a first-class citizen in the .NET ecosystem, not a separate mobile island. As one Microsoft program manager put it in the announcement blog: “The best .NET runtime is now the only runtime for all your apps.”

For Windows-focused developers, this alignment also means that skills and tooling transfer seamlessly between desktop and mobile projects. The same CoreCLR knowledge that powers high-performance Windows applications now directly benefits smartphone experiences. In an era where mobile apps often serve as entry points to larger experiences, .NET MAUI on CoreCLR positions developers to deliver fast, lean, and consistent cross-platform software with less effort than ever before.