The best observability tools for Kotlin Multiplatform in 2026

Kotlin Multiplatform has crossed the threshold. It is no longer experimental. Google and JetBrains have both committed to it, Compose Multiplatform on iOS is stable, and teams are shipping production apps across Android, iOS, Desktop, and WASM from a shared codebase.

The tooling has matured too, with one exception: observability.

Most monitoring tools were built for a single platform. Firebase Crashlytics is Android and iOS, but treats them as separate apps. Datadog and New Relic were built for backend and web. None of them were designed around a shared Kotlin codebase, a Koin dependency graph, or the specific failure modes that show up in KMP apps.

This post covers what observability actually means for KMP teams, where the existing tools fall short, and which tools are worth using in 2026.

What KMP observability needs to do

Before evaluating tools, it helps to be clear about what the problem is. A KMP app has a shared module containing business logic, ViewModels, repositories, and services, plus platform-specific UI layers on top. When something goes wrong, the failure usually originates in the shared module but surfaces differently depending on the platform.

A tool that only monitors Android will miss crashes that surface on iOS from the same root cause. A tool that only captures stack traces won't tell you that a ViewModel was blocking the main thread because of a heavy dependency resolution in the Koin graph. A tool with per-platform instrumentation doubles your setup work and gives you fragmented data you have to correlate manually.

Good KMP observability needs to:

• Capture crashes across all targets with fully desymbolicated Kotlin stack traces
• Understand the shared module structure, not just the platform layer
• Require a single SDK integration in commonMain, not per-platform setup
• Surface component state, session context, and thread activity alongside crash data
• Give you enough context to identify whether a bug is in shared code or platform-specific code

Most tools satisfy one or two of these. Very few satisfy all of them.

The tools worth knowing

Kotzilla

Kotzilla is the only observability platform built specifically for Koin and KMP. It integrates at the dependency injection layer, which means it understands your app's component structure from the inside rather than monitoring it as a black box from the outside.

Setup lives in your shared Koin module:

            
                   
 
Kotlin
// commonMain/kotlin/com/yourapp/App.kt
fun initKoin() = startKoin {

    modules(appModule)

    monitoring() // single line — works across all KMP targets

}
            
      

That one call instruments crash reporting, performance monitoring, session tracking, and dependency graph visibility across every target your app runs on. No per-platform SDK configuration, no manual trace points.

What you get:

Crash reporting with dependency context. When a crash occurs, Kotzilla captures not just the stack trace but the state of the Koin dependency graph at that moment. You can see which component failed, what it depended on, and whether the dependency was correctly scoped.

            
                   
 
// Kotzilla surfaces issues like this automatically:

// ComponentResolutionException in shared module

// -> UserRepository depends on NetworkClient

// -> NetworkClient was resolved on Main thread (blocking)

// -> Session: 3 screens visited, 12s since cold start
            
      

Cross-target session data. Sessions are tracked uniformly across Android, iOS, Desktop, and WASM. A crash on iOS from shared business logic shows up in the same dashboard as Android crashes from the same code path.

Performance monitoring for KMP-specific failure modes. Kotzilla tracks slow component resolutions, blocking ViewModels, ANRs, and frozen screens. These are issues that generic APM tools miss because they don't understand Koin's resolution lifecycle.

MCP server for AI-assisted debugging. The Kotzilla MCP server connects your AI coding assistant to this production data. Instead of pasting stack traces into Claude Code or Cursor, your assistant gets the full session context, dependency graph, and crash history automatically.

            
                   
 
# In your MCP config (claude_desktop_config.json or .cursor/mcp.json)

{
 
  "mcpServers": {
   
    "kotzilla": {
     
      "command": "npx",
     
      "args": ["-y", "@kotzilla/mcp-server"],
     
      "env": {
       
         "KOTZILLA_API_KEY": "your_api_key"
     
        }
   
     }
 
  }
}
            
      

Best for: Any team using Koin with Android or KMP apps that wants production observability without per-platform instrumentation.

Website: kotzilla.io

Firebase Crashlytics

Crashlytics is the default starting point for most Android teams and many iOS teams. It is free, well-documented, and integrates tightly with the Firebase ecosystem.

For KMP teams, the story is more complicated. Crashlytics has separate SDKs for Android and iOS. You configure them separately, they report to separate dashboards, and correlating a crash in shared Kotlin code across platforms requires manual investigation.

Kotlin stack traces on iOS go through the Objective-C runtime layer and are not automatically desymbolicated by Crashlytics. You get partial traces that require additional tooling to make readable.

Best for: Android-only teams or teams that need a free crash reporting baseline and are willing to accept the KMP limitations.

Not for: Teams who want unified cross-platform observability from a shared Kotlin codebase.

Sentry

Sentry is one of the more capable general-purpose error monitoring tools and has made genuine progress on mobile support. It offers Android and iOS SDKs, performance monitoring, session replay, and a reasonably good developer experience.

For KMP specifically, Sentry's support is still platform-specific. The Android SDK is mature. The iOS SDK works but requires separate configuration. There is no native KMP SDK that integrates at the shared module level.

// Android (androidMain) SentryAndroid.init(context) { options ->     options.dsn = "your_dsn"     options.tracesSampleRate = 1.0 }  // You still need separate iOS init in iosMain or native code 

Sentry's performance monitoring is strong for network requests and UI rendering but does not understand Koin dependency resolution or shared module lifecycle. You can add manual breadcrumbs to track component state, but this requires instrumentation work that Kotzilla handles automatically.

Best for: Teams already using Sentry on the backend who want to unify error monitoring across their stack, and are building primarily for Android.

Not for: Teams who need Koin-aware observability or want a single SDK covering all KMP targets.

Embrace

Embrace is a mobile-focused observability platform with strong session capture capabilities. It records 100% of user sessions, which gives you complete visibility into what a user did before a crash occurred.

Embrace supports Android and iOS natively. KMP support is not native but the Android SDK works well for teams whose KMP app has Android as the primary target.

The session replay and network monitoring features are genuinely useful for mobile teams. The pricing model based on MAU is predictable. The limitation for KMP teams is the same as Sentry: per-platform setup, no understanding of the shared Kotlin module layer.

Best for: Teams who need rich session context and are monitoring Android as their primary target.

Not for: Teams who need unified observability across all KMP targets from a single integration.

New Relic Mobile

New Relic's mobile offering covers Android and iOS with APM features including crash reporting, network monitoring, HTTP response tracking, and custom events. For teams already using New Relic for backend monitoring, the mobile SDK allows you to correlate frontend crashes with backend traces.

For KMP teams the picture is similar to Sentry and Embrace: separate Android and iOS SDKs, no native KMP integration, no awareness of Koin or shared module structure.

// androidMain only NewRelic.withApplicationToken("your_token")     .start(context) 

New Relic's strength is backend-to-frontend correlation. If your KMP app communicates with a backend you already monitor in New Relic, you can trace a slow network response from the mobile session through to the backend service. That is useful but not specific to KMP.

Best for: Enterprise teams with existing New Relic infrastructure who want mobile APM in the same platform.

Not for: Teams who want KMP-native observability or lightweight setup.

The gap that matters

Every tool in this list except Kotzilla was built before KMP was a serious production choice. They model mobile apps as Android apps or iOS apps, with separate reporting and separate dashboards.

KMP changes the model. Your business logic lives in a shared module. A bug in that shared module can surface on Android as a crash, on iOS as a frozen screen, and on Desktop as an ANR. A tool that treats these as three separate events gives you three separate investigations when you should be doing one.

The observability tooling for KMP is still catching up to the platform. Kotzilla is the only tool in 2026 that was designed for this model from the start.

Choosing the right tool

If you are starting a new KMP project or migrating from Android-only, start with Kotzilla. The single-line setup and cross-target visibility are worth it from day one.

If you are on Android-only and not planning to expand to other targets, Firebase Crashlytics is the pragmatic free choice. Sentry is worth paying for if you want better performance monitoring and are already using it on the backend.

If you need session replay or full-fidelity user journey tracking alongside crash data, Embrace is the strongest mobile-specific option for Android.

No tool currently gives you everything: free, KMP-native, session-aware, dependency-graph-aware, and backend-correlated. Kotzilla gets the closest for KMP teams specifically.

Kotzilla is an observability platform built for Android and Kotlin Multiplatform developers. It integrates via Koin to give you crash reporting, performance monitoring, and full session context across every KMP target from a single SDK setup. Learn more at kotzilla.io.