What Is .NET MAUI?

Analogy categoryAnalogies

.NET Multi-platform App UI (MAUI) is Microsoft's open-source, cross-platform framework for building native mobile and desktop apps from a single C# and XAML codebase. It is the evolution of Xamarin.Forms, redesigned as a first-class part of the unified .NET runtime starting with .NET 6, so the same project can target Android, iOS, macOS (via Mac Catalyst), and Windows (via WinUI 3).

🏏

Cricket analogy: Like a franchise fielding the same core batting lineup across the IPL, the Hundred, and international T20s while adapting slightly to each ground, MAUI lets you write one C#/XAML codebase that adapts to iOS, Android, Windows, and macOS.

From Xamarin.Forms to .NET MAUI

Xamarin.Forms required a separate .NET runtime (Mono) from classic .NET, and its project structure forced you to maintain a shared PCL/netstandard project plus one head project per platform (Droid, iOS, UWP), each with its own csproj. MAUI collapses this into a single project file that uses multi-targeting (TFMs like net8.0-android, net8.0-ios) so platform-specific code lives in conditional folders instead of separate projects, and it runs on the same Base Class Library as ASP.NET Core and console apps.

🏏

Cricket analogy: Xamarin.Forms was like carrying three separate kit bags for Test, ODI, and T20 cricket; MAUI is one adaptable kit bag with dividers, since a single csproj now multi-targets android and ios instead of separate head projects.

Core Architecture: Handlers and Native Controls

MAUI apps are not rendered with a custom drawing engine; each MAUI control (Button, Entry, CollectionView) maps through a 'handler' to a real native control (android.widget.Button, UIButton, Microsoft.UI.Xaml.Controls.Button on Windows). This handler architecture replaced Xamarin.Forms' heavier 'renderer' pattern, is faster because handlers use a leaner mapping/property-mapper dictionary instead of deep inheritance chains, and lets you register a custom handler to tweak native behavior per platform without subclassing the whole control.

🏏

Cricket analogy: It's like an umpire's decision going through DRS, which maps the on-field call to ball-tracking, snicko, and hot-spot systems per format, similarly MAUI maps one Button control through a handler to the real native widget on each OS.

xml

<!-- MainPage.xaml: one XAML file renders as native controls on every platform -->
<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             x:Class="HelloMaui.MainPage">
    <VerticalStackLayout Padding="30" Spacing="15">
        <Label Text="Welcome to .NET MAUI!"
               FontSize="24"
               HorizontalOptions="Center" />
        <Button Text="Click me"
                Clicked="OnCounterClicked"
                x:Name="CounterBtn" />
    </VerticalStackLayout>
</ContentPage>

When to Choose MAUI

MAUI is the right fit when a team already knows C#/.NET, needs to ship to at least two of Android/iOS/Windows/macOS from one codebase, and wants genuinely native controls rather than a custom-rendered canvas (which is what Flutter uses). It competes most directly with Flutter (Dart, own rendering engine) and React Native (JavaScript, native bridge); MAUI's advantage is deep integration with existing .NET libraries, Visual Studio tooling, and enterprise codebases that already run ASP.NET Core backends, while its ecosystem of third-party controls is smaller than React Native's.

🏏

Cricket analogy: Choosing MAUI over Flutter is like a franchise picking a captain who already knows the domestic circuit inside out rather than importing an overseas star, since teams with existing C# skills get native controls without learning a new language like Dart.

MAUI ships as a workload inside the .NET SDK (dotnet workload install maui), meaning you get MAUI project templates via dotnet new maui from the command line, not just Visual Studio — useful for CI pipelines and VS Code + JetBrains Rider users.

Because handlers wrap real native controls, deep pixel-perfect custom UI (e.g., an unusual shaped scroll gesture) may require writing a custom handler or partial platform-specific class — MAUI is not a fully custom-rendered canvas like Flutter, so some advanced visual customization takes more platform-specific code.

.NET MAUI is Microsoft's cross-platform framework for building native Android, iOS, Windows, and macOS apps from one C#/XAML codebase.
It succeeds Xamarin.Forms and runs on the unified .NET runtime (.NET 6+) instead of the separate Mono runtime Xamarin used.
A single multi-targeted project file replaces the old pattern of separate head projects per platform.
MAUI renders through 'handlers' that map each control to a genuine native widget, not a custom-drawn canvas.
MAUI is installed as a .NET SDK workload and supports both Visual Studio and CLI-based (dotnet new maui) workflows.
It is best suited to teams already invested in C#/.NET who want native controls with a single shared codebase.
Deep custom UI behavior may still require platform-specific handler code, unlike fully custom-rendered frameworks like Flutter.