.NET MAUI, short for .NET Multi-platform App UI, is an open source framework for building native mobile and desktop applications for Android, iOS, macOS and Windows from a single C# and XAML codebase. In app development, .NET MAUI is the successor of Xamarin.Forms and the main cross-platform UI option within the .NET ecosystem, aimed at teams that want to share both business logic and user interface across platforms.
The framework became generally available in 2022 alongside the .NET release of that period and is now updated together with each new .NET version. It renders native platform controls rather than drawing its own widgets, which distinguishes it from several competing frameworks.
How .NET MAUI builds native apps
A .NET MAUI app is written once in C# with optional XAML markup for layouts. At build time, the same project is compiled for each target platform using the matching .NET runtime: .NET for Android, .NET for iOS, .NET for Mac Catalyst and the Windows App SDK with WinUI 3. Each platform build produces a real native package, such as an APK or AAB, an IPA or an MSIX installer.
The bridge between shared code and the platform is the handler architecture. A cross-platform control, such as a Button, is mapped by a handler to the native control on each platform, for example a native Android button or a UIKit button on iOS. Handlers replaced the heavier renderer system of Xamarin.Forms and make it easier to customize a single property of a native control without rewriting the whole control.
| Platform | Native layer used | Typical output package |
|---|---|---|
| Android | Android views via .NET for Android | APK or AAB |
| iOS and iPadOS | UIKit via .NET for iOS | IPA |
| macOS | Mac Catalyst | App bundle |
| Windows | WinUI 3 and Windows App SDK | MSIX or unpackaged executable |
Linux desktop is not an officially supported target. Community projects exist, but teams that require Linux usually choose another framework.
Key features and building blocks
The defining feature is the single project structure. Instead of one project per platform, as in Xamarin.Forms, a .NET MAUI app keeps shared code, images, fonts and app icons in one project, with platform-specific folders only where native code is genuinely required. Resources such as an SVG icon are resized automatically for every platform.
| Building block | Purpose | Notes |
|---|---|---|
| XAML and C# markup | Declare user interfaces | XAML is optional; pure C# also works |
| Data binding and MVVM | Connect views to view models | Toolkit libraries reduce boilerplate |
| Shell | Navigation, flyouts and tabs | URI-based routing between pages |
| Platform APIs | Sensors, storage, connectivity, sharing | Unified cross-platform interfaces |
| BlazorWebView | Host Blazor web components natively | Basis of Blazor Hybrid apps |
| Hot reload | Update running app while debugging | Supports XAML and C# changes |
The Blazor Hybrid model deserves attention. It lets teams reuse web UI components written in Razor inside a native app shell, with full access to device APIs. This suits organizations that already build web applications with Blazor and want shared components across web and native.
Comparison of .NET MAUI with other cross-platform frameworks
Cross-platform frameworks differ mainly in language, rendering approach and ecosystem. .NET MAUI uses native controls, while Flutter draws its own widgets with a rendering engine, and React Native maps JavaScript components to native views. Kotlin Multiplatform focuses on sharing business logic, with optional shared UI.
| Framework | Language | UI rendering | Best fit |
|---|---|---|---|
| .NET MAUI | C# and XAML | Native controls through handlers | Teams invested in .NET and desktop needs |
| Flutter | Dart | Own rendering engine | Pixel-identical UI on all platforms |
| React Native | JavaScript or TypeScript | Native views from components | Web teams using React |
| Kotlin Multiplatform | Kotlin | Native UI or shared Compose UI | Shared logic with native look |
| Ionic with Capacitor | Web technologies | WebView | Web apps packaged for stores |
A practical strength of .NET MAUI is first-class Windows desktop support next to mobile, which matters for line-of-business apps used on both tablets and office PCs. Its main weakness, often reported by developers, is a smaller third-party control ecosystem than the largest competitors.
Choosing and setting up .NET MAUI
Development happens mainly in Visual Studio on Windows or with the .NET command-line tools and editor extensions on macOS and Windows. Building and signing iOS apps always requires access to a Mac with Xcode, either locally or as a paired build host, because Apple tooling runs only on macOS. Android builds need the Android SDK, which installs with the workload.
| Situation | Recommendation | Reason |
|---|---|---|
| Existing C# and .NET team | Strong candidate | Reuses skills, libraries and tooling |
| Migration from Xamarin.Forms | Natural successor | Similar concepts and upgrade tools |
| Internal apps on mobile and Windows | Good fit | One codebase covers both |
| Need for Linux desktop | Choose another framework | No official Linux target |
| Highly custom, game-like UI | Consider Flutter or native | Native controls limit pixel control |
Limitations and common pitfalls
Because .NET MAUI wraps native controls, appearance and behavior can differ slightly between platforms, and some bugs appear on only one of them. Testing on real devices for every target is therefore essential, not optional.
- App size and startup time can exceed fully native apps; trimming and ahead-of-time compilation help.
- Platform updates from Apple or Google sometimes require a framework update before apps can be rebuilt.
- Third-party libraries written for Xamarin may need replacements or updated versions.
- Complex animations and highly custom controls may need platform-specific code.
Teams should also follow the .NET support lifecycle, because each .NET MAUI release is supported only as long as its .NET version, which means planned upgrades roughly every one to two years.
The short version
.NET MAUI lets developers write an app once and run it on Android phones, iPhones, Macs and Windows computers. Think of it as one recipe that each kitchen cooks with its own local ingredients, so the result feels at home on every device.
The key benefit is one team and one codebase instead of four separate apps, which saves time and keeps features consistent.
Where it makes a difference
A field service company sends 250 technicians to repair heating systems. Its old system used a Windows desktop app in the office and separate, outdated mobile apps for Android and iOS used by technicians, built by different contractors.
An internal team of four C# developers rebuilds everything as one .NET MAUI app with shared view models, offline storage and photo capture. The same code runs on Android tablets, iPhones and office Windows PCs, with only about 5 percent of the code specific to a platform. New features now ship to all devices in one release, and the team estimates that maintenance effort fell by more than half. The outcome is consistent tools for the whole workforce.