Financial TimesAmericas' Fastest-Growing 2025
Certified PartnerOdoo Gold · Adobe Gold Solution · Shopify Premier partnershipsOdoo Gold · Adobe Gold · Shopify Premier partnerSee all
One business dayA senior architect replies to every inquiry · +1 (631) 897-7276Architect reply within one business dayLet's talkCall us
Inc. Regionals 2025Fastest-growing private companies in AmericaInc. Regionals 2025 honoreeSee awards
Americas' Fastest-Growing Companies 2025Recognized by the Financial TimesFT Fastest-Growing Companies 2025See the rankingRanking
4.8 / 5 on Clutch265 verified client reviews4.8/5 on Clutch · 265 reviewsRead the reviews
4.8 · 265 Clutch reviews
US United States
April 9, 202513 min readUpdated on October 21, 2026

Xamarin end of support: your app still runs, but it can't ship updates

· Vice President, Microsoft Technologies
Xamarin end of support: your app still runs, but it can't ship updates

Xamarin end of support arrived on May 1, 2024, and it covers every Xamarin SDK, Xamarin.Forms included. Your app didn't stop working that day. What stopped is your ability to ship it: Google Play and the App Store now require SDKs that Xamarin can't build against.

So the app opens, customers log in, orders go through. Then a developer pushes a one-line fix, and the store rejects the build before anyone looks at a screen. This guide covers what the end of support froze, which store rules you can't meet, and the steps to move a Xamarin.Forms or Xamarin native app to .NET 10.

What Xamarin end of support covers, and what it froze

Microsoft's Xamarin support policy says support ended on May 1, 2024 "for all Xamarin SDKs including Xamarin.Forms." That means Xamarin.Android, Xamarin.iOS and Xamarin.Forms. Microsoft defines end of support as the date it "no longer provides fixes, updates, or online technical assistance." Security patches are part of that. A vulnerability found in the Xamarin runtime or bindings today stays open.

The policy also froze the platform targets. Android API 34 and the Xcode 15 SDKs (iOS and iPadOS 17, macOS 14) are the last versions Xamarin targets, and no new APIs are planned. Microsoft's instruction is that these projects "should be upgraded to .NET SDK-style projects for continued support."

Xamarin product Last supported version End of support
Xamarin.Android 13 13.2.2.0 (targets API 34) May 1, 2024
Xamarin.iOS 16 16.0.523 (works with Xcode 15) May 1, 2024
Xamarin.Forms 5.0 5.0.0.2612 May 1, 2024

Is Xamarin dead, then? The brand and the SDKs are. The idea isn't. Starting with .NET 6, Xamarin.Android, Xamarin.iOS and Xamarin.Mac became .NET for Android, .NET for iOS and .NET for Mac. Xamarin.Forms evolved into .NET Multi-platform App UI (.NET MAUI). Writing cross-platform mobile apps in C# carries on under those names.

Why the stores block your next release

Microsoft's date was the formal end. The practical deadline was the first store rule your app couldn't meet, and for most teams that date has passed on both platforms.

On Android, Google Play's target API rules required new apps and updates to target Android 15 (API 35) from August 31, 2025. From August 31, 2026, the bar is Android 16 (API 36), with extensions available to November 1, 2026. Xamarin.Android tops out at API 34, so you can't submit an update at all.

Existing apps lose reach as well. An app must target API 35 or higher to stay available to new users on newer Android devices. Anything at API 34 or lower is only offered to devices running that Android version or older. Current users keep the app. New customers on recent phones won't find it.

On iOS, Apple's rule changed on April 28, 2026. Its requirements page says apps uploaded to App Store Connect must be built with Xcode 26 or later. Xamarin.iOS 16 works with Xcode 15. That closes App Store submissions, new apps and updates alike.

Date What happened What it means for a Xamarin app
May 1, 2024 Microsoft ends support for all Xamarin SDKs No fixes or security patches
August 31, 2025 Google Play requires API 35 for new apps and updates Updates blocked (Xamarin stops at API 34)
November 11, 2025 .NET 10 and .NET MAUI 10 ship This is your migration target
April 28, 2026 Apple requires Xcode 26 for App Store uploads Uploads blocked (Xamarin.iOS stops at Xcode 15)
May 12, 2026 .NET MAUI 9 reaches end of support Don't migrate to MAUI 9
August 31, 2026 Google Play requires API 36 for new apps and updates Still blocked; .NET 10 meets it
November 10, 2026 .NET 8 and .NET 9 reach end of support A port to .NET 8 lands on another unsupported version
May 11, 2027 .NET MAUI 10 reaches end of support Plan the next upgrade now

Building the app is getting harder too. A March 2024 FAQ on the official .NET MAUI GitHub repository said the last supported Visual Studio 2022 versions would keep building Xamarin apps. It also warned that Azure Pipelines builds may need extra steps to fetch the required dependencies. Each macOS and Xcode image your CI provider retires adds to that work.

MAUI, .NET for Android and iOS, or a different framework?

For a working C# codebase, staying on .NET is the short path. Shared code, tests and developer skills carry over. A rewrite in another framework throws away years of tested code, so it only makes sense when the C# codebase is already a problem for other reasons.

That said, the end of support is a fair moment to look at the Xamarin alternatives.

Option Best fit Trade-off
.NET MAUI Xamarin.Forms apps with shared UI and C# teams Annual upgrades to stay inside the support window
.NET for Android and .NET for iOS Xamarin native apps with platform-specific UI You still maintain 2 UI layers
Uno Platform or Avalonia C# and XAML teams that want another open-source UI stack Smaller ecosystem, separate vendor roadmap
Flutter Teams willing to rewrite in Dart for one shared UI Full rewrite, new language
React Native Teams with strong JavaScript and React skills Full rewrite, new language
Kotlin Multiplatform Android-first teams that want to share logic with iOS Full rewrite, Kotlin skills needed
Native Swift and Kotlin Apps that need deep platform features 2 codebases to maintain

Flutter is open source, backed by Google and written in Dart. React Native is maintained by Meta and builds native Android and iOS apps with React. JetBrains calls Kotlin Multiplatform production ready, and its Compose Multiplatform UI is stable on iOS. Uno Platform (Apache 2.0) and Avalonia (MIT) both keep C# and XAML, and Uno also targets WebAssembly and Linux, which .NET MAUI doesn't list.

One more case to rule out first. If the app is being replaced within a few months, a full port may cost more than it saves. Freeze it, write down the security risk and spend the budget on the replacement.

Before you start: confirm which Xamarin you built

"Xamarin" covered 2 ways of building apps, and they migrate to different places. Open the solution and check before anyone writes a plan.

Xamarin native (often called traditional Xamarin) is Xamarin.Android and Xamarin.iOS. Business logic is shared in C#, and each platform keeps its own UI written against the Android or iOS APIs. Microsoft's archived docs describe bindings for nearly the entire iOS and Android SDKs. iOS builds compiled ahead of time to native ARM code, while Android builds ran on Mono alongside the Android runtime.

Xamarin.Forms adds a shared UI layer. Microsoft describes it as an open-source UI framework for Android, iOS and Windows apps from a single shared codebase. You write the UI once in XAML or C#, often with MVVM, and platform renderers turn it into native controls.

Xamarin native (Android and iOS) Xamarin.Forms
What you share Business logic, models, services and tests Logic plus most of the UI
How the UI is built Separately per platform, with native APIs Once, in XAML or C#, rendered as native controls
Typical project structure Shared code plus an Android project and an iOS project Shared .NET Standard library plus thin platform projects
How you customize a control Directly, in platform code Custom renderers, effects or platform-specifics
Where it migrates to .NET for Android and .NET for iOS .NET MAUI
Typical migration effort Lower: mostly project files and packages Higher: namespaces, APIs, renderers and layouts

The old Xamarin.Forms vs native debate weighed shared UI against full control of each platform's screens. That trade-off no longer drives anything. Only the last 2 rows of the table matter now.

Xamarin apps were native apps in the output sense, too. They compiled to an .apk on Android and an .ipa on iOS and called platform APIs through C# bindings. What set them apart from Swift and Kotlin was the language and the shared code. That's also why going fully native means a rewrite rather than a port.

Two project types have no direct route. Xamarin.watchOS has no upgrade path, and Microsoft suggests bundling Swift extensions with a .NET for iOS app instead. OpenGL on iOS isn't available either, because OpenTK isn't supported there.

Set the target and the tooling

Target .NET 10. It's a long term support release with runtime support until November 14, 2028. .NET for Android in .NET 10 supports API 36 and JDK 21, which covers the Google Play bar from August 31, 2026. The .NET 10 release for iOS requires Xcode 26, which matches Apple's upload rule.

Note the shorter MAUI clock. Each .NET MAUI major version is supported for 6 months after its successor ships, so MAUI 10 support ends on May 11, 2027, long before the .NET 10 runtime does. Budget for a yearly upgrade.

On tooling, older guides point to the .NET Upgrade Assistant, which Microsoft now lists as officially deprecated. Microsoft recommends the GitHub Copilot modernization chat agent instead, included with Visual Studio 2026 and Visual Studio 2022 17.14.16 or later. Its own guide says the app will need more work after the tool runs in most cases, so treat that pass as a first draft.

Xamarin.Forms to .NET MAUI, step by step

Microsoft's upgrade guide frames the job well. Every project has to become SDK-style, but projects don't need to be rewritten. Business logic and most of your code come across, with namespace and API changes on the way. If your team is new to MAUI, read the .NET MAUI beginner's guide first.

1. Get to Xamarin.Forms 5 and current packages

Microsoft's manual upgrade guide asks you to update to Xamarin.Forms 5, update dependencies to their latest versions and confirm the app still works. That shrinks the API gap and exposes broken packages while you still have a running app to compare against.

2. Audit every third party package

Most of the effort hides here, so do it before anyone quotes a timeline. Microsoft notes that Xamarin.Forms NuGet packages generally aren't compatible with modern .NET unless they've been recompiled with .NET target framework monikers. Packages built only for xamarinios, monotouch or xamarinmac won't work. Android is more forgiving, and packages targeting monoandroid can still be used.

Each failing package leaves 3 choices: recompile it if you own the code, find a .NET version, or replace it with one that does the same job. One abandoned package can change the whole plan. If Brainvire's .NET MAUI development team picked up your port, this package-by-package list is the first thing we'd hand back, before any estimate.

3. Convert every project to SDK-style

Old Xamarin project files are verbose and platform-specific. SDK-style projects are the format every .NET workload uses. Microsoft's suggested route is to create a new .NET MAUI project with the same name, then copy your code, configuration and resources into it. It's mechanical, but it touches every project in the solution, so work on a branch.

4. Update namespaces and changed APIs

Start with a find-and-replace. Xamarin.Forms becomes Microsoft.Maui and Microsoft.Maui.Controls, and the default XAML namespace changes too. Then work through the APIs that moved:

  • Colors move to Microsoft.Maui.Graphics, and color values become float rather than double.
  • The Device class is deprecated. Its jobs move to types such as DeviceInfo, MainThread and the dispatcher.
  • Application.Properties gives way to .NET MAUI Preferences.
  • Startup moves to one MauiProgram class that every platform calls, with dependency injection built in.

Xamarin.Essentials is now part of .NET MAUI, so most of those device APIs come across with namespace changes only.

5. Port custom renderers and effects to handlers

Renderers and effects need code changes. .NET MAUI replaces renderers with handlers, which use mappers to push property changes from a cross-platform control to its native view. Microsoft says this decouples native views from the controls, so native views no longer subscribe to control events. You can also customize a mapper without subclassing.

Through .NET 10, the optional Microsoft.Maui.Controls.Compatibility package can still host Xamarin.Forms renderers. Don't lean on it. Microsoft no longer builds or ships that package in .NET 11, so every usage becomes a blocker at your next upgrade. Converting during the first port is cheaper. Start with custom controls that wrap native controls, since that's where most renderer code lives.

6. Migrate stored user data

This is the step teams miss. Data saved through Xamarin.Forms app properties, Xamarin.Essentials secure storage or version tracking needs an explicit migration. Skip it, and users are logged out the moment they install the update. Microsoft documents the migration steps for each store, and they belong in the plan from day 1.

7. Fix layouts screen by screen

The app will build before it looks right. Microsoft's layout notes explain why. Grids no longer add missing rows, StackLayouts no longer fill leftover space and default spacing drops from 6 to 0. Put the old and new builds side by side and compare every screen. XAML Hot Reload speeds this up, because UI edits show in the running app without a rebuild.

8. Pilot one flow, then release in stages

Pick one real user flow, such as login through to a first order, and take it all the way to a test build on real devices. That pilot tells you how much time the rest will need. Migrate the core flows next, test on both platforms as you go, and ship through each store's testing track before the full release.

Xamarin native apps: a shorter route

Xamarin.Android and Xamarin.iOS apps skip most of the steps above. Microsoft's native upgrade guide says most projects won't need namespace changes or other rewrites. You create a new .NET for Android or .NET for iOS project with the same name. Then you copy in code, resources and settings such as code signing, fix incompatible packages and build. The package audit from step 2 still applies, and it's still where the surprises are.

Once the app runs on .NET for Android and .NET for iOS, shared UI can come in gradually. Native embedding lets those apps use .NET MAUI controls, so new screens can be shared while existing native screens stay put. Navigation still runs through each platform's native API.

Troubleshooting the first MAUI build

Most problems after the first successful build come from a short list. These are drawn from Microsoft's troubleshooting guidance and layout notes.

What you see Why it happens Fix
Screens look cramped, with no spacing MAUI layout defaults changed from 6 to 0 Add implicit styles that restore the old values
Controls overlap in a Grid MAUI doesn't infer missing rows or columns Declare RowDefinitions and ColumnDefinitions
A view no longer fills the screen MAUI stack layouts don't subdivide space Replace StackLayout with Grid where children must fill
A BoxView disappears Default size changed from 40x40 to 0x0 Set WidthRequest and HeightRequest
A list won't scroll A StackLayout lets CollectionView grow past the screen Put the list inside a Grid
Users are logged out after the update Secure storage and app properties data wasn't migrated Run Microsoft's data migration steps for each store
Code on resume stops running OnAppearing no longer fires when the app returns to the foreground Use Window lifecycle events
A custom renderer or effect does nothing Renderer and effect code needs changes Port it to a handler, or update it for MAUI

Brainvire is a Microsoft Solutions Partner, and the same team can keep a legacy Xamarin app stable while the port runs, alongside your wider mobile app work. The useful first conversation is about your package list. Send it to us and we'll tell you which items will hold up the move.

FAQ

Is Xamarin still supported in 2026?

No. Microsoft ended support for all Xamarin SDKs on May 1, 2024, and the app stores have since moved past Xamarin's last SDKs. Apple has required Xcode 26 for App Store uploads since April 28, 2026. Google Play requires API 36 for new apps and updates from August 31, 2026.

Will my existing Xamarin app stop working?

Not by itself. A March 2024 FAQ on the official .NET MAUI GitHub repository said existing apps would "continue to work" after support ended. The risks are unpatched security issues, no way to ship updates through the stores and shrinking reach on Google Play for new users on newer devices.

Do the store deadlines apply to an internal company app?

Not always. Google's target API rules exempt permanently private apps restricted to one organization, so an app that never goes through a public store won't be blocked by those deadlines. The missing security patches still apply, and security and compliance teams will likely flag an unsupported framework at the next audit.

Is .NET MAUI the same as Xamarin?

No, but it's the direct successor. Microsoft calls .NET MAUI the evolution of Xamarin.Forms, extended from mobile to desktop, with UI controls rebuilt from the ground up. It adds a single project structure, handlers in place of renderers and built-in device APIs, and runs on Android, iOS, macOS and Windows. Xamarin.Android and Xamarin.iOS live on as .NET for Android and .NET for iOS.

ShareLinkedInXEmail

Related reading

Xamarin app blocked from the stores? Plan the .NET MAUI move

Plan my migration