Crash Reporting in .NET MAUI 10 After App Center: Sentry, Crashlytics, and Raygun Compared

So, Microsoft App Center officially retired on March 31, 2025, and a year later there are still thousands of .NET MAUI and Xamarin teams shipping with the dead SDK baked in. If you never swapped it out, you're flying blind right now — no crash reports, no analytics, no distribution. Honestly, I've seen production apps in this state and the team had no idea their crash rate had tripled. This guide walks through the three replacements actually worth your time in 2026 — Sentry, Firebase Crashlytics, and Raygun — with working .NET MAUI 10 integration code, a feature comparison, and an honest recommendation for each app shape.

Why App Center's retirement matters for .NET MAUI teams

App Center was the default observability story Microsoft pushed for Xamarin and early .NET MAUI: one SDK, one portal, crashes plus analytics plus distribution all in a single bundle. Convenient. After retirement, the Microsoft.AppCenter.* NuGet packages still install fine — but the back end is gone. Crashes get silently dropped. Analytics events vanish into the void. And the SDK keeps an in-memory buffer that just grows until it's evicted.

If your app still references Microsoft.AppCenter.Crashes or Microsoft.AppCenter.Analytics, do this today:

1. Remove the App Center SDK packages from your .csproj.
2. Delete any AppCenter.Start(...) calls from MauiProgram.cs and platform startup.
3. Pick a replacement (this guide) and ship a hotfix.

Until the SDK is gone, you're paying app startup time and battery for telemetry that goes nowhere. Not great.

What you actually need from a crash reporter in 2026

Before comparing vendors, let's pin down what "good enough" really means for a .NET MAUI app. Most teams need:

• Native + managed stack traces. .NET MAUI runs on top of MonoVM (or NativeAOT on iOS, depending on how you publish). A useful crash report has to symbolicate both the managed System.NullReferenceException and the underlying native frames.
• dSYM and ProGuard/R8 mapping upload. iOS release builds strip symbols; Android R8 obfuscates names. Without mapping uploads, your stack traces are essentially useless.
• ANR / hang detection. An app that freezes is worse than one that crashes — users just uninstall it and leave a one-star review.
• Breadcrumbs. The 20 or so navigation events, HTTP calls, and log lines before the crash. This is the single biggest debugger productivity multiplier I know of.
• Release health. "Crash-free users %" per release, so you know when to roll back.
• Reasonable pricing. Crash volume scales with your DAU, and you want predictable cost, not a surprise bill after a viral moment.

Option 1: Sentry — the most "drop-in" App Center replacement for MAUI

Sentry has invested heavily in first-class .NET MAUI support. As of Sentry .NET SDK 4.x, there's a dedicated Sentry.Maui package with automatic breadcrumbs for navigation, screen-render, and lifecycle events. It's the closest thing to a drop-in replacement on this list.

Installing Sentry in a .NET MAUI 10 project

dotnet add package Sentry.Maui

Wire it up in MauiProgram.cs:

public static MauiApp CreateMauiApp()
{
    var builder = MauiApp.CreateBuilder();
    builder
        .UseMauiApp<App>()
        .UseSentry(options =>
        {
            options.Dsn = "https://[email protected]/0";
            options.Debug = false;
            options.TracesSampleRate = 0.2;          // 20% perf traces
            options.ProfilesSampleRate = 0.2;        // mobile profiling
            options.AttachScreenshot = true;         // PII-safe by default
            options.IncludeTextInBreadcrumbs = false;
            options.Release = $"com.example.app@{AppInfo.VersionString}+{AppInfo.BuildString}";
            options.Environment = "production";

            // .NET MAUI specific
            options.CreateElementEventsBreadcrumbs = true; // tap/swipe breadcrumbs
        });

    return builder.Build();
}

Capturing handled exceptions

try
{
    await _orderService.PlaceAsync(cart);
}
catch (HttpRequestException ex)
{
    SentrySdk.CaptureException(ex);
    await Shell.Current.DisplayAlert("Network error", "Please try again.", "OK");
}

Uploading dSYMs and ProGuard mappings

Sentry ships a CLI that you can call straight from your CI pipeline:

# iOS dSYMs (after dotnet publish -f net10.0-ios -c Release)
sentry-cli debug-files upload --include-sources \
  ./bin/Release/net10.0-ios/ios-arm64/publish/MyApp.app.dSYM

# Android ProGuard / R8 mapping
sentry-cli debug-files upload \
  ./obj/Release/net10.0-android/android-arm64/mapping.txt

Sentry strengths

• True cross-platform symbolication for managed + native frames.
• Built-in session replay for mobile (preview as of late 2025, but already useful).
• Performance monitoring is bundled — no separate SDK to bolt on.
• Generous free tier: 5k errors and 10k traces per month.

Sentry weaknesses

• Pricing climbs quickly past the free tier if you don't sample.
• ANR detection on Android needs a small extra config block (easy to miss).

Option 2: Firebase Crashlytics — free, but harder in .NET MAUI

Crashlytics is free and battle-tested. The catch? Google doesn't ship a first-party .NET binding. You'll need the community Plugin.Firebase.Crashlytics package (or the AdamE.Firebase.iOS.Crashlytics / Xamarin.Firebase.Crashlytics bindings underneath it).

Installing Plugin.Firebase.Crashlytics

dotnet add package Plugin.Firebase.Crashlytics
dotnet add package Plugin.Firebase.Auth   # if you also want analytics signed-in user mapping

You also need the platform-specific bootstrap files:

• GoogleService-Info.plist in Platforms/iOS with build action BundleResource.
• google-services.json in Platforms/Android with build action GoogleServicesJson.

Initialize in MauiProgram.cs

builder.UseMauiApp<App>()
       .RegisterFirebaseServices();   // extension from Plugin.Firebase

// Then anywhere in your app:
CrossFirebaseCrashlytics.Current.SetCrashlyticsCollectionEnabled(true);
CrossFirebaseCrashlytics.Current.SetUserId(userId);
CrossFirebaseCrashlytics.Current.Log("Cart checkout started");

try { /* ... */ }
catch (Exception ex)
{
    CrossFirebaseCrashlytics.Current.RecordException(ex);
    throw;
}

The catch with managed stack traces

Here's where it gets messy. Crashlytics was designed for native Java/Kotlin and Swift/Obj-C, so without extra effort your managed .NET exception shows up as a single native frame with the message and basically no useful stack. The community plugin works around this by serializing the managed stack into a custom non-fatal record. It works, but it's noisy — you lose Crashlytics' "issue grouping" magic because every crash ends up looking slightly different.

Crashlytics strengths

• Truly free, no event cap.
• Best-in-class ANR detection on Android (native instrumentation, hard to beat).
• Integrates with Firebase Analytics, Remote Config, and Performance Monitoring.

Crashlytics weaknesses

• No official Microsoft or Google support for .NET MAUI — you depend on community bindings.
• Managed stack trace grouping is unreliable.
• iOS dSYM upload through MSBuild is fiddly; many teams just script it manually.

Option 3: Raygun — the "App Center successor" UX

Raygun publishes an official Mindscape.Raygun4Maui package and explicitly markets itself as an App Center replacement. The dashboard, breadcrumb model, and SDK surface area are the closest to what App Center looked like — if you're chasing minimum cognitive churn for your team, this is the one.

Installing Raygun4Maui

dotnet add package Mindscape.Raygun4Maui

builder
    .UseMauiApp<App>()
    .AddRaygun(opts =>
    {
        opts.ApiKey = "YOUR_RAYGUN_API_KEY";
        opts.EnableCrashReporting = true;
        opts.EnableRealUserMonitoring = true;
        opts.ApplicationVersion = AppInfo.VersionString;
    });

Raygun strengths

• First-party .NET MAUI SDK — single package, no community bindings to babysit.
• Real User Monitoring (RUM) for screen load times ships in the same SDK.
• Pricing is per error event, not per user — predictable for B2C apps with traffic spikes.

Raygun weaknesses

• No free production tier — only a 14-day trial.
• Smaller ecosystem than Sentry; fewer integrations with PagerDuty, Slack routing variations, etc.
• No session replay yet.

Side-by-side: Sentry vs Crashlytics vs Raygun for .NET MAUI 10

Feature	Sentry	Crashlytics	Raygun
Official .NET MAUI SDK	Yes (Sentry.Maui)	No (community plugin)	Yes (Raygun4Maui)
Managed stack symbolication	Excellent	Workable	Excellent
ANR / hang detection	Yes, opt-in	Yes, on by default	Limited
Breadcrumbs (navigation, taps)	Auto	Manual	Auto
Performance / RUM	Bundled	Separate SDK (Firebase Perf)	Bundled
Free tier	5k errors/mo	Unlimited	14-day trial only
Session replay (mobile)	Preview	No	No
Self-hosting option	Yes	No	No

Migration recipe: replacing App Center in an existing MAUI app

This is the exact order of operations we use on production apps. I've migrated three of them with this recipe, and the wrapper step (number 2) is the one that always saves the day:

1. Audit usages. Grep for Crashes., Analytics., and AppCenter.Start. Each one needs a 1:1 replacement.
2. Wrap your old API. Create an ITelemetry interface in your app with methods like TrackEvent, TrackError, SetUser. Implement it once against App Center (so the app still compiles), then re-implement against your new vendor.
3. Ship the wrapper-only release. No behavior change, but suddenly the rest of the codebase no longer references App Center directly.
4. Swap the implementation. Replace the App Center body with Sentry/Crashlytics/Raygun. Run a few canary builds.
5. Verify symbol upload in CI. Force a test crash via a hidden debug menu and confirm the stack trace actually looks readable in the dashboard.
6. Remove all Microsoft.AppCenter.* packages. Only after at least one release proves the new SDK works.

Example: a vendor-agnostic ITelemetry interface

public interface ITelemetry
{
    void TrackEvent(string name, IDictionary<string, string>? props = null);
    void TrackError(Exception ex, IDictionary<string, string>? props = null);
    void SetUser(string? userId, string? email = null);
    void Breadcrumb(string message, string category = "app");
}

public sealed class SentryTelemetry : ITelemetry
{
    public void TrackEvent(string name, IDictionary<string, string>? props = null)
        => SentrySdk.CaptureMessage(name, scope =>
        {
            if (props is null) return;
            foreach (var (k, v) in props) scope.SetTag(k, v);
        });

    public void TrackError(Exception ex, IDictionary<string, string>? props = null)
        => SentrySdk.CaptureException(ex, scope =>
        {
            if (props is null) return;
            foreach (var (k, v) in props) scope.SetTag(k, v);
        });

    public void SetUser(string? userId, string? email = null)
        => SentrySdk.ConfigureScope(s => s.User = new() { Id = userId, Email = email });

    public void Breadcrumb(string message, string category = "app")
        => SentrySdk.AddBreadcrumb(message, category);
}

Register it in DI: builder.Services.AddSingleton<ITelemetry, SentryTelemetry>();. Now switching vendors is one line. Future you will say thanks.

Privacy and data residency in 2026

GDPR enforcement around mobile telemetry tightened noticeably in 2025. Before you ship any of these SDKs, confirm:

• Data region. Sentry supports EU-only ingestion (de.sentry.io); Raygun has EU and US regions; Crashlytics stores in the US by default.
• PII scrubbing. All three SDKs let you scrub IPs, emails, and request bodies — turn it on at init time, not after a complaint lands in your inbox.
• App Tracking Transparency. On iOS 18+, any analytics SDK that collects an advertising identifier needs an ATT prompt. Sentry and Raygun don't by default; Crashlytics (paired with Firebase Analytics) may — read your build settings carefully.

My recommendation by app shape

• Pre-revenue or solo dev. Crashlytics. It's free, the ANR detection is excellent, and you can live with the awkward managed stack grouping.
• Funded startup / production B2C app. Sentry. Best-in-class .NET MAUI integration, predictable bill if you sample, and you get performance monitoring in the same SDK. This is what I'd pick for a new project today.
• Enterprise / regulated industry. Sentry self-hosted, or Raygun with EU residency. Both let you avoid sending crash payloads to US-based SaaS.
• Migrating from App Center with minimum disruption. Raygun. Its dashboard and SDK shape will feel the most familiar to your team.

Frequently Asked Questions

Is App Center really gone, or can I still use it?

It's fully retired as of March 31, 2025. The portal is offline, ingestion endpoints return 410, and the SDK packages remain on NuGet only for source compatibility. Any data still in your account is unrecoverable.

Can I use Application Insights instead of these tools for a .NET MAUI app?

You can, but Application Insights was built for ASP.NET server workloads. It has no managed-stack symbolication for mobile, no dSYM upload, and no ANR detection. It's a fine fit only if you already have an Azure-centric stack and you only want to log custom events — not for serious crash reporting.

Does Sentry work with NativeAOT on iOS in .NET MAUI 10?

Yes, as of Sentry .NET SDK 4.10+. Stack traces from NativeAOT-published apps need you to upload the .dwarf debug info alongside the regular dSYM — the sentry-cli debug-files upload command handles both automatically when you point it at the publish folder.

Will Firebase Crashlytics for .NET MAUI ever be official?

No signal from Google as of early 2026. The community Plugin.Firebase maintainers track Firebase SDK releases within a few weeks, which has been good enough for production for several years — but officially, you're on community support.

How do I do A/B testing and feature flags now that App Center Distribute is gone?

Distribute and feature flags were always separate concerns from crash reporting. For distribution, use TestFlight + Firebase App Distribution. For feature flags, Microsoft.FeatureManagement with Azure App Configuration, ConfigCat, or LaunchDarkly all have working .NET MAUI clients in 2026.

Conclusion

App Center's retirement wasn't a surprise — Microsoft announced it more than a year in advance — but plenty of .NET MAUI apps still ship with the dead SDK installed. Pick one of the three replacements above, hide it behind an ITelemetry interface, and you'll never face this migration pain again. If you have to pick one for a new project today: Sentry has the deepest .NET MAUI integration, the most useful breadcrumbs out of the box, and the most predictable upgrade path as your app scales.