What's new

New updates and improvements to Kotzilla Platform

September 3rd, 2026

This update brings a new Jira integration (Console 4.14.1), plus updates to the MCP Server (1.15.1) and the SDK (2.3.5):

• Turn a detected issue into a Jira ticket, with the context already in it (Console): the ticket carries the root cause, the impacted sessions, the exact app and version, a link back to the Kotzilla issue, and a ready-to-run MCP prompt.
• Follow the ticket without leaving Kotzilla: the issue shows the live Jira status and assignee. The Console mirrors the ticket, Jira stays the source of truth.
• Verify a fix before you close it (MCP Server): after applying a fix, your assistant rebuilds, runs, and confirms it against a fresh session, structurally and on timing, for performance issues and now crashes.
• More accurate timings and safer crash delivery (SDK 2.3.5): background time no longer inflates screen render or startup measurements, and a detected crash is always sent right away.

Kotzilla Console 4.14.1

Kotzilla now connects to Jira, so a critical issue you find in the Console becomes an actionable ticket in the tool your team already works in. Detection stays in Kotzilla, the ticket lives in Jira, and the fix happens in your editor, with the same context flowing through all three.

A ticket that already carries the context

When you create a Jira ticket from an issue, Kotzilla pre-fills it from what it captured. The ticket body contains the diagnosis and root cause, the dependency graph with resolution timings, the impacted sessions, and the exact app and version. It includes a direct link back to the Kotzilla issue, and a ready-to-run prompt for the Kotzilla MCP Server (get_issue_context and get_fix_guidance), so whoever picks up the ticket, or their AI assistant, goes straight to the fix with the real runtime context. One ticket per issue.

Follow the ticket from the issue

Once linked, the issue shows the ticket key as a deep link, its live status, and its assignee. The status and assignee are mirrored read-only: the Console follows the ticket lifecycle, it does not manage tickets, and Jira remains the source of truth. You can also link an existing ticket to an issue, or unlink one. Unlinking only removes the link inside Kotzilla, it never deletes the ticket in Jira.

Connect Jira for your organization

An organization admin connects Jira once from Org Settings, using OAuth, and picks a default project. Each app can override that project from its own settings. See Jira ticket integration for the full setup.

Kotzilla MCP Server 1.15.1

Verify a fix before you close it

After your assistant applies a fix, it confirms the fix actually worked. It rebuilds, runs the app, and checks that a fresh session arrived, then verifies the fix two ways:

• structurally, that the anti-pattern is gone (the component is off the main thread, out of the startup graph, lazy, created once);
• on timing, comparing the new version against the same issue in the same local environment, not against generic production thresholds.

Crashes are covered too: the assistant reproduces the crash first, then confirms the exact path that crashed now runs clean.

You do not need to ask for the check, it runs as part of the fix:

Fix the ANR in my app Now In Android

Kotzilla SDK 2.3.5

SDK 2.3.4 and 2.3.5 sharpen measurement accuracy and crash delivery.

• Accurate screen render time. A screen sent to the background mid-navigation no longer reports the backgrounded time as slow render or ANR time (Android for now).
• Honest startup timing. A process woken in the background (push, job, broadcast) that later opens its first screen is now reported as a warm start, instead of counting the whole idle wait as cold startup.
• Crashes are never held back. A crash detected while the SDK's connection is temporarily blocked is now sent right away, instead of being held locally for up to the block duration.

See the full list in the SDK changelog.

August 5th, 2026

This update brings new capabilities across the Kotzilla Platform, including the Console (4.13.0), the Koin IDE Plugin (1.6.0), the MCP Server (1.12.1), and the SDK (2.3.3):

• Connect your AI assistant to Kotzilla from the IDE (Koin IDE Plugin): one dialog wires your AI coding assistants to the Kotzilla MCP, so they can analyze your app's real production issues, trace root causes, and apply guided fixes without leaving your editor.
• Works with more than Koin: Kotzilla now monitors apps built with Hilt, Metro, Dagger, or manual DI too, with setup guided by the MCP Server.
• App-wide performance and stability analysis (Console): a new All Versions view analyzes the whole app, flags what needs attention, and shows how your latest release is performing.
• A more robust SDK (2.3.3): build and multiplatform fixes since 2.3.0, including reliable root-level plugin apply and iOS/Compose linking.

Kotzilla Console 4.13.0

An All Versions view of your app's health

The Dashboard now offers an All Versions view: a single analysis of the whole app that surfaces what needs attention, next to how your latest deployed version is performing. Teams get a clear read on the app overall and on the new release at once, without switching versions. It shows version distribution, an Application Health summary across all versions, and the last version detected, each linking into the issues behind the numbers.

Selecting a specific version keeps the familiar per-version view (Health & Stability, App startup, Critical Issue Trends, and Screen Rendering).

Now monitoring apps built with Hilt, Metro, or manual DI

Kotzilla now monitors apps built with Hilt, Metro, or manual DI, not just Koin. Here are Google's Now in Android (Hilt) and JetBrains' KotlinConf app (Metro) running in the Console. See Setup with Hilt, Metro, or manual DI for what is supported today.

Koin IDE Plugin 1.6.0

Plugin 1.6.0 brings one-dialog MCP setup for AI coding assistants, plus faster indexing and more accurate Koin understanding.

Connect AI assistants to Kotzilla MCP from the IDE

From a single Connect dialog in Android Studio or IntelliJ IDEA, wire your AI coding assistants to the Kotzilla MCP Server. They get the full context Kotzilla captures, your app's dependency structure and its real production behavior, so they can analyze issues, find root causes, and apply guided fixes in your code.

• Covers 11 assistants today, including Claude Code, OpenAI Codex, Gemini CLI, Cursor, Windsurf, GitHub Copilot, Junie, and JetBrains AI Assistant.
• Shows each assistant only when it is detected in your environment.
• Choose exactly which to connect with per-assistant checkboxes.
• See which are already connected, and disconnect them (or get exact manual cleanup steps) from the same place.

The Koin Configuration tool window suggests connecting when nothing is set up yet:

The Connect dialog lists the assistants detected in your environment, each with its own checkbox and scope:

Once connected, your assistant can call the Kotzilla MCP tools directly. Here GitHub Copilot runs a report inside the IDE:

Faster, more accurate Koin understanding

Koin indexing is faster and steadier, with near-instant updates after small edits and fewer full graph rebuilds. DSL and Annotations parsing is more accurate, covering scoped definitions, dynamic parameters, fully qualified and receiver-style calls, typed constructor declarations, and @KoinWorker. Android ViewModel navigation, searchable app selection, mutable list bindings, and multi-project switching are all smoother.

Kotzilla MCP Server 1.12.1

The MCP Server can now set up the SDK in projects that do not use Koin. Ask your AI assistant to set up Kotzilla, and it detects your dependency injection setup and configures the SDK accordingly, whether the app uses Koin, Hilt, Dagger, Metro, or manual DI, including the build wiring that KSP projects (Hilt, Room) need.

For example, in a Hilt or Metro app:

Register my app on Kotzilla and set up the SDK

The assistant detects there is no Koin, adds the Gradle plugin and kotzilla.json, and wires the right startup for each target. See Setup with Hilt, Metro, or manual DI.

Kotzilla SDK 2.3.3

SDK 2.3.3 rolls up build and multiplatform fixes since 2.3.0.

• Reliable root-level plugin apply. Applying the plugin at the root no longer breaks multi-module KMP builds: the KotzillaScreenHost has none or several references compile error and the Xcode dSYM setup race are fixed, so root-level apply is safe again.
• KMP iOS with Compose. Fixed a capability conflict that could fail iOS framework linking when both kotzilla-sdk and kotzilla-sdk-compose were present, and corrected the iOS early-start module export that followed from it.
• Android backup and manifest. Fixed the 2.3.0 manifest-merger conflict for apps that declare their own backup rules. SDK state now lives in noBackupFilesDir, excluded from Android backup by construction, so you can remove any tools:replace workaround.
• Compose route and startup fixes. A route content lambda with an early return no longer breaks R8/D8 minified builds, and a Koin-logger self-reference that could crash the app on startup is fixed.
• Build report and Gradle robustness. The build report now covers all versions of the app, the build-id task no longer conflicts with source-generating tasks, and a missing Kotlin source set warns instead of failing Gradle sync.

See the full list in the SDK changelog.

Issue detection and thresholds

We tuned detection to cut noise and keep the focus on what impacts users, and aligned thresholds with Google Play targets.

Fewer, higher-signal issues. Detection now centers on the issues that impact users: crashes, ANRs, slow screens, slow transitions, cold and warm startup, and main-thread and background-thread performance.

Three dependency issue types are retired, since they generated a lot of noise:

• Dependency Performance
• Child Dependency Performance
• Dependency Complexity

The cases that actually block users still surface: a dependency resolution over 100 ms on the main thread is still detected as a Main Thread Performance issue. Sessions analyzed before this change still show the retired types; new sessions do not. See Retired issue types.

Detected issues and their thresholds. These are the issue types detected today and the threshold at which each is raised:

Issue	Detection threshold
Slow screen	500 ms
Slow transition	500 ms
Cold startup	3500 ms
Warm startup	1500 ms
ANR	4500 ms
Background thread	200 ms
Main thread	100 ms

July 7th, 2026

This update brings new capabilities across the Kotzilla Platform, including the SDK (2.3.0), the Console (4.12.0), and the MCP Server (1.11.1):

• Privacy-first data collection: gate the entire SDK behind explicit user consent, off by default so nothing changes unless you opt in.
• Automatic startup capture: the SDK now boots at process start, so crashes and startup timing are caught from the earliest possible moment.
• See who is impacted, down to the session (MCP Server): your AI assistant breaks affected sessions down by device and OS and points you to the worst session behind an issue.
• Monitor what matters, per version: turn data collection on or off per app version, from the Console or your AI assistant, to cut noise and cost.
• Guided fixes from Issue Details (Console): each issue hands off to the Kotzilla MCP Server for a guided fix in your editor.

Kotzilla SDK 2.3.0

SDK 2.3.0 focuses on privacy, automatic startup, and startup performance.

Universal consent gate

Apps that must obtain user opt‑in before collecting any data can now gate the entire SDK behind explicit consent. Turn it on with kotzilla { consentRequired = true }, then record the user's decision:

KotzillaSDK.setConsent(KotzillaConsent.GRANTED)   // or NOT_GRANTED

Until a decision is recorded, the SDK buffers telemetry locally and sends nothing. On grant, the buffer is replayed; on refusal (or forgetMe()), it is wiped along with in‑flight uploads and native crash files. The gate is off by default, so upgrading from 2.2.x changes nothing. See Privacy & user consent.

Automatic start (early start)

The SDK now boots automatically at process start (before Application.onCreate on Android, before main() on iOS, and on first SDK reference on the JVM), so crashes and startup timing are captured from the earliest possible moment, even before your monitoring() call. It is on by default and can be disabled globally or per platform. See Automatic start (early start).

Startup performance

Every launch now produces an automatic cold/warm startup metric (duration + launch source; Android for now), and a new mark(label, track) API lets you time your own startup phases. See Startup tracing.

Latest ecosystem support

Verified against Kotlin 2.4.x, AGP 9.2.1, Gradle 9.6.0, Jetpack Compose BOM 2026.06.00, and Compose Multiplatform 1.11.1.

Bump the version and rebuild:

id("io.kotzilla.kotzilla-plugin") version "2.3.0" apply true

See the full list in the SDK changelog.

Kotzilla Console 4.12.0

The Console side of this release reworks issue details around metrics and a guided MCP resolution flow, and adds per-version monitoring controls.

Reworked Issue Details

Issue Details now leads with the metrics that matter for each issue and a resolution flow that hands off to the Kotzilla MCP Server, so you go from an issue to a guided fix in your editor. Performance status is now handled consistently across screens and issues.

Per-version monitoring toggles

Application Settings now lets you enable or disable monitoring per app version. Controls are read-only when you do not have permission to change them, and an inactive app shows a clear paused banner. The same per-version control is available directly from the Kotzilla MCP Server.

Timeline session summary and smaller improvements

The Timeline session summary now carries more metadata fields and SDK properties, adds an event thread display, and improves duration and scope ID formatting.

Kotzilla MCP Server 1.11.1

The MCP Server adds impacted-population analysis and per-version data gating, so your AI assistant can tell you who is affected by an issue and control what the platform ingests.

See who is impacted, down to the session

When you ask about an issue, the assistant can now give you the exact population behind it: which devices, which OS versions, and how many production sessions each one hit. get_issue_context returns that breakdown plus a list of impacted sessions sorted by worst or most recent, and you can filter issues, screens, and issue context by device or OS. From there you drill straight into the worst session's timeline.

Per-version data gating

list_app_versions returns each app version with whether the SDK is ingesting data for it and whether it has a mapping file. set_app_versions_enabled turns ingestion on or off per version. This is the same per-version monitoring toggle available in the Console, usable directly from your AI assistant.

See the Kotzilla MCP Server page for the full reference.

June 18th, 2026

This update ships the SDK (2.2.3), a recommended upgrade that corrects how Koin events are ordered in the session timeline.

Kotzilla SDK 2.2.3

Correct timeline ordering of Koin events

Koin events — DI resolutions, module load, eager instances, scope create/drop — now keep their true chronological position in the session timeline, relative to Activity, Fragment, and Compose screen events.

Previously, dependency work performed very early in the app lifecycle could appear after the first screen event even though it happened before it. The most visible case was the startKoin / module-load / eager-singleton resolutions that run during Application.onCreate: they would show up later in the timeline than the first Activity event, because Koin events were numbered when the SDK drained its internal buffer rather than at the moment they occurred. Activity, Fragment, and Compose events were already stamped at the moment they happened, so the two could disagree.

In 2.2.3, every event is sequenced at the instant it occurs. The timeline now matches wall-clock order across the Koin ↔ screen boundary, so screen-rendering and startup analysis attribute the right work to the right phase (for example, the Application.onCreate DI cost is no longer mixed into an Activity's create→resume window).

This is a recommended upgrade for any app that relies on timeline ordering or screen-rendering metrics. There are no API or configuration changes — bump the version and rebuild:

id("io.kotzilla.kotzilla-plugin") version "2.2.4" apply true

See the full list in the SDK changelog.

June 16th, 2026

This update brings new capabilities across the Kotzilla Platform, including the Console (4.7.0) and the SDK (2.2.2):

• ANRs and slow screens are now Critical issues: detected automatically and shown in the Issues View, with the Dashboard ANR-free rate linking straight to them.
• Reliable deobfuscation across builds: a single app version can now hold several mapping files, so component names, dependencies, and crash stack traces always resolve to the exact mapping of the build that produced them.
• More accurate Compose render timing: Compose screens now measure render time and time to interactive directly on-device.
• Faster onboarding: a new MCP-guided setup flow in the Console, plus refreshed setup instructions for SDK libraries.
• Monitoring you can trust in production: the SDK absorbs its own errors and handles network drops quietly, so it never crashes or slows your app, and it keeps collecting data through bad networks.

Kotzilla Console 4.7.0

The Console side of this release makes ANRs and slow screens first-class critical issues, brings end-to-end mapping file management, adds a faster MCP-guided onboarding, and refreshes the UI.

ANRs and slow screens as Critical issues

ANRs and slow-rendering screens now appear in the Issues View, across both the Critical Issues and All Issues tabs, alongside every existing issue type (startup, main and background thread performance, dependency performance, crashes, and more). One prioritized place to see what is hurting your users the most.

Drill into ANRs from the Dashboard

The ANR-free rate on the Dashboard is now clickable. Selecting it takes you straight to the Critical Issues view filtered by ANRs, so you can go from a health number to the actual ANRs behind it in one click and analyze them as a first-class issue.

End-to-end mapping file management

Rebuilding the same version name used to overwrite the previous mapping file, leaving component and dependency names only partially deobfuscated. A single version can now keep several mapping files, so every signal, from component and dependency names to crash stack traces, resolves to the exact mapping of the build that produced it, thanks to the per-build Build ID generated by the SDK (see below). You can still upload mapping files manually, and now download any of them by ID directly from the Console.

See Mapping files for production builds for the full workflow.

MCP-guided onboarding

Setting up a new app now starts with a setup choice screen. You can pick the recommended MCP-guided flow, where one prompt to your AI assistant registers the app and applies all the SDK changes for you, or choose manual setup, which still walks you through the existing step-by-step instructions for your project type.

Clearer onboarding for SDK libraries

If you are monitoring an SDK library rather than an app, the Console onboarding now shows how to start Kotzilla from your library's isolated Koin context. Use koinApplication { ... } (not startKoin { ... }) so your SDK's context stays separate from the host app's, and call monitoring() last, after your modules(...) and includes(...). The plugin supplies the key from kotzilla.json, so there is nothing to wire by hand.

See the SDK setup for SDK libraries guide for the full flow.

Refreshed UI and smaller improvements

This release refreshes the UI: icons migrate to Lucide with harmonized design tokens and sizing, toast notifications are added, and the application settings UI is improved. A few more refinements:

• Tables are more readable, with a fixed layout, optional column resizing, responsive widths, and a middle ellipsis that keeps the meaningful last segment of long dotted names (for example com.go…MainActivityViewModel), with full names on hover.
• The Screen Rendering table now uses a clickable screen name in place of the Analysis icon, the invite-user form no longer keeps stale state, duration filtering was removed from impacted sessions, and the ambiguous quota alert was deactivated.

Kotzilla SDK 2.2.2

SDK 2.2.2 (and 2.2.1) sharpen screen-performance data for Compose apps, make crashes always resolve to the right mapping file, and harden the SDK so it never interferes with your app.

More accurate Compose screen render timing

Kotzilla now measures how long your Compose screens take to render directly on-device, using a monotonic clock from the moment a screen is created. The timing is no longer inferred from server-side timestamps, which were sensitive to clock skew, batching, and event ordering. Each screen reports two numbers:

• Render time: from screen creation to the first frame painted on screen.
• Time to interactive: from creation to fully resumed, which also includes the navigation transition.

In a session, the Compose lifecycle states carry these timings: the Visible state reports the render time, and the Resumed state reports the time to interactive.

This works identically for Navigation 2 and Navigation 3, and adds no new fields to the event payload (the timings ride the existing timeInMs field on SCREEN_LIFECYCLE events). While developing, enable debug logs to see a per-screen breakdown:

[Kotzilla] Screen '<name>' load funnel — CREATED/STARTED/VISIBLE/RESUMED at +<n>ms

Crashes always resolve to the exact mapping

The plugin now generates a per-build Build ID and tags every session and mapping upload with it, so crashes resolve to the exact mapping that produced them even when several builds share the same version name. On Android this is per-variant, so a release build and a minified staging build no longer overwrite each other's mappings. Each session also reports whether the build was minified, so the Console can tell a genuinely missing mapping from a build that was never obfuscated.

Monitoring you can trust in production

Every point where the SDK touches your app now absorbs its own errors. Network failures (DNS, offline, timeout, TLS) are handled quietly instead of surfaced as SDK errors, and the initial connection retries indefinitely with jittered backoff, reconnecting after network loss.

Richer crash and navigation context

Crash reports now include the last resumed screen (route and visit) at crash time. Route visibility is more reliable, with VISIBLE/HIDDEN events emitted from the route host node so trivial wrapper routes track correctly. Forward navigation and back-pop are now distinguished, fixing inflated session counts, and native Activity and Fragment screens report elapsed time on pause and destroy.

Reliability and compatibility

This release also fixes multi-module builds (no more prepareLintJarForPublish failures or per-module version warning spam), makes Apple/Xcode tasks skip gracefully off-macOS or without Xcode, ensures monitoring() resolves right after a Gradle sync on KMP, CMP, and JVM, and recognizes Koin 4.x module loading and navDeepLink patterns at compile time.

See the full list in the SDK changelog, and the setup details in the SDK Libraries, KMP, and CMP guides.

May 19th, 2026

This update introduces new capabilities and improvements in the Kotzilla Platform, including the Console (4.5.0) and the SDK (2.2.0):

• Compose Navigation visibility across all KMP targets: Compose screens and events appear in the Dashboard and Timeline, so you can spot a slow screen, whether it is an Activity, Fragment, or Compose screen, find its root cause, and fix it.
• Readable crash stack traces: each frame is labeled with its origin (Kotlin, Java, Objective-C, or system), so you can quickly pinpoint where a crash originates.
• Google Play-aligned health thresholds: the Dashboard health rates use thresholds aligned with Google Play targets.
• Build-time regression checks: Gradle builds now execute a Kotzilla report so regressions are caught before release.

Kotzilla Console 4.5.0

The Console side of this release focuses on making the new Compose screen data readable, plus crash analysis, new app health thresholds, support for smaller screens, and localization.

Compose screens in the Dashboard and Timeline

Compose Navigation screens from SDK 2.2.0 are now first-class in the Console. In the Dashboard, the Screen Rendering table lists each Compose screen with its rendering times, sessions, and ANRs, tagged with a COMPOSE_NAV3 (or COMPOSE_NAV2) type, right next to Activity and Fragment screens.

In a user session, the Timeline renders Compose lifecycle (SCREEN_LIFECYCLE) events with their own grouping, colors, and symbols, interleaved with Android activity events and Koin resolutions. You see the exact sequence of Compose screens a user moved through and what happened on each one, so a Compose-based or multiplatform app gets the same screen-level visibility as a classic Android view app.

Structured stack traces for crashes

Crash stack traces are now normalized and rendered with their frame origins labeled. On Android you can tell Kotlin (KT) frames apart from Java frames at a glance. On iOS, frames are tagged as Kotlin (KT), Objective-C (ObjC), or System, so you can immediately see whether a crash originates in your Kotlin code, platform glue, or the OS.

Dashboard health thresholds

The Dashboard health indicators now use thresholds aligned with Google Play targets, so a green status means the app is genuinely in good shape. ANR detection is also stricter: ANRs are now flagged at 2 seconds instead of 5 seconds.

Crash-free rate

Status	Range	Meaning
Green	>= 99.50%	Healthy
Orange	99.00% - 99.49%	Below target, needs attention
Red	< 99.00%	Google Play flags at 98.91%

ANR-free rate

Status	Range	Meaning
Green	>= 99.53%	Above the Google Play threshold
Orange	99.00% - 99.52%	Below the Google Play flag
Red	< 99.00%	Serious problem

Slow Component free rate (Kotzilla specific)

Status	Range	Meaning
Green	>= 90.00%	Clean architecture
Orange	75.00% - 89.99%	Optimization needed
Red	< 75.00%	Major DI performance issues

Homepage app status

The homepage now classifies each app into a clear state: healthy (no critical issues), not configured, quiet (configured but no analyzed sessions in the last 14 days), or to investigate (critical issues found). Session counts are aligned consistently across the platform, the default window is 14 days, and the dashboard overview is now scoped to the selected version and timestamp.

Small-screen support

The Console now adapts to small screens, so you can review issues, sessions, and the timeline from a narrow window or a smaller device without layout breakage.

French localization

The Console is now available in French, with locale-aware date, time, and number formatting and proper pluralization across the home, apps, issues, timeline, and sessions views.

Kotzilla SDK 2.2.0

SDK 2.2.0 brings full Compose Navigation coverage (including Navigation 3) across every KMP target, a build-time report that surfaces issues before you ship, and a wide set of reliability fixes for config resolution, mapping uploads, crash replay, and browser targets.

Navigation 3 and richer Compose screen tracking

Navigation 3 screens are now tracked for all KMP targets: Android, iOS, Desktop (JVM), JS, and WASM. Compose typed routes keep their full route name in Kotzilla, with safe route details attached when available. This applies to both Navigation 2 and Navigation 3.

Compose Navigation route boundaries (Navigation 2 and Navigation 3) are auto-instrumented. Each screen visit emits a Compose lifecycle (SCREEN_LIFECYCLE) event, and Compose screens are tagged with screenType = compose_nav2 or compose_nav3, while Activities and Fragments keep activity / fragment. You see each detected screen and its route on the Console timeline alongside the rest of your app's runtime behavior.

Build report in your Gradle build

Gradle builds now print the Kotzilla report for the selected app version, run by auto-wired kotzillaBuildReport{Variant} tasks, so you catch regressions before release.

By default the build fails on a FAIL status. If you don't want the report to block the build, opt out in the kotzilla { ... } block of your app, shared, or ComposeApp module:

kotzilla {
    skipBuildReportFailure = true
}

Simpler plugin setup

The Kotzilla Gradle plugin is now applied at the root with apply true (previously apply false). This makes the plugin process every module in your project, including feature modules with Compose Navigation routes, with no extra configuration for multi-module setups.

// root build.gradle.kts
plugins {
    alias(libs.plugins.kotzilla) apply true
}

The module-level plugin block in your app, shared, or ComposeApp module stays as before. Feature modules do not need a Kotzilla API key; only your app or main runtime module does.

Automatic Android versionCode

Android apps now report the runtime versionCode automatically, separately from the version name, so versions are unambiguous in the Console. Manual and non-Android integrations can still set it explicitly with setVersionCode(...).

Reliability and compatibility

This release includes a broad set of fixes:

• Compose route starts: visits are no longer missed when a destination is already resumed before Kotzilla attaches.
• Generated config ownership: Android apps fail fast when more than one runtime dependency owns the generated config. Keep kotzilla.json or projectFile in a single app/runtime module. Multi-key config is now strict.
• Build-time app version detection: generated config, mapping uploads, and dSYM uploads use the same app version.
• iOS dSYM setup: setupKotzillaXcode handles nested and more complex Xcode project layouts; the fix applies automatically on sync or rebuild.
• AGP 9.2 mapping uploads: work with R8/L8 outputs and bundle<Variant>, with no configuration cache conflicts.
• Crash replay deduplication: delivered crash reports are never resent.
• JS/WASM event delivery: page-close saves, localStorage quota recovery, and gzip/CORS fallback now work on browser targets.

Compatibility ceilings expanded: Kotlin 2.3.20, AGP 9.2.0, Gradle 9.5.0, Compose BOM 2026.04.01, AndroidX Navigation Compose 2.9.8, Compose Multiplatform 1.10.3.

Action required

• Android consumers now need compileSdk 35+. Navigation 3 Android projects need compileSdk 36+ and minSdk 23+. KMP native/web requires Kotlin 2.2+.
• iOS nested projects: rerun setupKotzillaXcode (automatic on sync or build).

See the full list in the SDK changelog and the setup details in the KMP and CMP guides.

April 27st, 2026 - Kotzilla MCP Server

The Kotzilla MCP Server is now generally available.

The MCP Server gives your AI coding assistant (Claude Code, Cursor, Windsurf, Android Studio, and others) a set of tools to analyze the performance and stability of your app, plus the context needed for root cause analysis and apply accurate fixes. This context is based on your app's structure, runtime behavior from real user sessions, and a knowledge base of proven fix patterns for Android and Kotlin Multiplatform projects.

Install

Add the MCP Server to your assistant's configuration file:

{
  "mcpServers": {
    "kotzilla": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.kotzilla.io/mcp"]
    }
  }
}

Config file paths per assistant (Claude Code, Cursor, Windsurf, Android Studio) and the full flow are documented in the MCP Server quick start.

App registration and SDK setup in one prompt

Ask your assistant:

Register my app on Kotzilla and set up the SDK

The assistant reads your project structure (package name, app type), registers the app on the platform, and applies all SDK changes: version catalog entries, Gradle plugin, kotzilla.json, and the monitoring() call in your Koin setup.

Manual setup is still available via the Koin IDE Plugin or the Kotzilla Console.

App analysis and issue remediation in natural language

Once your first sessions are recorded, you can ask questions about crashes, ANRs, slow screens and any regression across app versions, and most importantly, get root causes and concrete code fixes, all in natural language and wired into your development environment. The Kotzilla Console dashboard remains available when you want a visual view of the same data.

Example prompts:

• Generate a report for my app: pass/warn/fail summary with crashes, ANRs, and prioritized fixes.
• Is version 1.2.1 performing better than 1.1.5?: cross-version regression check on sessions, issues, and component performance.
• Which issues should I focus on across all my apps?: issues ranked by severity across every registered app.
• Why is this screen slow?: the components blocking the render and the root causes behind them (heavy ViewModel init, slow dependency resolutions), with all the required context.
• How can I fix this issue?: fix pattern specific to the issue type (blocking calls, eager initialization, heavy ViewModel init, StateFlow strategies, scope misuse) applied directly in your code under your review.
• Show me the crashes on the iOS target of my CMP app and help me fix them : symbolicated iOS stack traces with suggested fixes.

Available tools

Tool	What it does
list_apps	List your registered apps
create_app	Register a new app
guide_sdk_installation	Get SDK setup instructions for your app type
generate_app_config	Generate kotzilla.json (creates a new API key each call)
get_platform_activity	See which apps are active and sending data
get_screen_performance	Screen rendering times and ANR counts
get_issues	Performance and architecture issues
get_issue_context	Dependency tree, timings, stack traces for a specific issue
get_fix_guidance	Fix patterns and best practices for a given issue type
generate_report	Performance summary report

See the Kotzilla MCP Server page for the full reference.

April 3rd, 2026 - SDK 2.1.3

SDK 2.1.3 marks the general availability of Kotlin Multiplatform observability.

A single SDK setup covers Android, iOS, Desktop (JVM), JavaScript (Browser and Node.js), and WebAssembly (Browser and Node.js), giving you unified issue detection, iOS crash reporting, and AI-assisted remediation across every target of your KMP or Compose Multiplatform project.

One Setup, All Targets

Add monitoring() to your shared module's Koin setup. The SDK detects the running platform at runtime and adapts automatically. No per-platform initialization code required.

// commonMain - shared module
import io.kotzilla.generated.monitoring

fun initApp() {
    startKoin {
        // Your Koin modules
        modules(appModule)
        // One line to monitor all targets
        monitoring()
    }
}

Drop your kotzilla.json in the shared module, apply the Gradle plugin, and you're collecting sessions from every target: Android, iOS, Desktop (JVM), JS, and WASM. See the KMP setup guide for the full setup.

iOS Crash Reporting

iOS crash reporting, previously in beta, is now stable. The SDK captures crashes using PLCrashReporter and includes the full Kotlin stack trace, not just the native one. Here is how it works:

1. Your app crashes on iOS. The SDK saves the crash data and the Kotlin stack trace to disk immediately.
2. On next launch, the crash report is uploaded to Kotzilla automatically.
3. The dSYM file (uploaded during your build) is matched to the report, producing a fully symbolicated, readable stack trace in the Console.

To enable dSYM symbolication, run this once (and again after SDK updates):

./gradlew setupKotzillaXcode

This injects a build phase script into your Xcode project that uploads dSYM files automatically on each build. No manual steps after the initial setup.

To disable iOS crash reporting if needed:

monitoring {
    onConfig { useIosCrashReport = false }
}

New Timeline Engine

The SDK now computes and structures timeline data on-device. Instead of forwarding raw Koin logs, the SDK builds structured timeline events (dependency resolutions, activity lifecycle, crashes) and assembles resolution dependency trees in real-time. This means the data arriving in the Console is already organized and contextualized, resulting in faster issue detection and more accurate root cause analysis. This also eliminates false positives in dependency chain detection that occurred when the server had to reconstruct the graph from raw logs.

The timeline also tracks now app state transitions (foreground, background, active), so you can correlate performance issues with lifecycle events and understand how your app behaves across state changes.

From Detection to Remediation

Issues from all targets show up in one dashboard, alongside health KPIs (Crash Free Rate, ANR Free Rate), startup metrics, and slow screen rankings.

Each detected issue includes root cause analysis and impacted sessions, and both the Kotzilla Console and the Koin IDE Plugin generate AI-assisted remediation prompts with full structural context (dependency graph, resolution times, call chains) so you can go straight from detection to a fix.

The Koin IDE Plugin is the recommended way to use these prompts: you are already in Android Studio with full access to your code, and AI coding assistants (GitHub Copilot, Gemini, Claude Code, AI Assistant, Junie) can apply fixes directly in your project.

AGP 9 and Expanded Compatibility

SDK 2.1.3 adds support for Android Gradle Plugin 9, including automatic detection of AGP 9's built-in Kotlin and recognition of the Android KMP plugin.

Core SDK:

Dependency	Supported Versions
Kotlin	2.1.0 - 2.3.20
Android Gradle Plugin	8.4.0 - 9.1.0
Gradle	8.6 - 9.4.0
Koin	4.0.4+
Android Compile SDK	34+
Android Min SDK	API 21+

Compose and Navigation (kotzilla-sdk-compose only, not needed for core SDK):

Dependency	Supported Versions
Jetpack Compose BOM (Android)	2024.11.00 - 2026.02.01
AndroidX Navigation Compose (Android)	2.8.5 - 2.9.7
Compose Multiplatform (KMP)	1.9.2 - 1.10.2
JetBrains Navigation Compose (KMP)	2.9.1 - 2.9.2

Notes

• Kotlin 2.4+ is accepted with a compatibility warning (the plugin does not block forward versions).
• KMP native/web targets (iOS, JS, WASM) require Kotlin 2.2.0+ due to a klib metadata format change. JVM/Android consumers can use Kotlin 2.1.0+.
• Compose Multiplatform 1.10.2+ is required when using Kotlin 2.3.x on native or web KMP targets (iOS, JS, WASM). 1.9.2 is sufficient for Android-only KMP or Kotlin 2.2.x and below.

March 16th, 2026 - Console 4.0.0

Console 4.0.0 is a major update that turns the Console into a performance and stability cockpit, guiding you from high-level KPIs straight to fixes. The new Dashboard provides a single view of your app's health, stability, and startup behavior, connecting business-impact KPIs (crash rates, ANR rates, slow screens) with the detected issues and root causes behind them.

New Dashboard

The Dashboard now provides a consolidated operational view of app performance, stability, and startup behavior:

• Health and stability KPIs - Slow Component Free Rate, ANR Free Rate, and Crash Free Rate with color-coded severity indicators. Each metric is clickable and navigates to the Issues View with the relevant filter applied.
• App startup metrics - New cold and warm startup cards showing P50 and P95 durations with severity indicators, replacing the previous generic startup metric. Click through to the Issues View filtered by startup type.
• Critical issue trends - A dual-axis time-series chart tracking performance issues and crashes over time. Each data point is clickable for day-level drill-down.
• Slow screens table - A new table ranking screens by rendering performance (P50, P95, sessions, ANRs) with an Analysis action that opens the Screen Details page.

New Screen Details page

Accessible from the Slow Screens table, this page breaks down why a specific screen is slow:

• Overview KPIs - P50 and P95 rendering time, sessions affected, ANRs, and status indicators.
• Top navigation patterns - The top 3 activity-level navigation sequences that include the screen, with session percentage for each pattern.
• Top blocking UI components - A ranked list of components contributing to screen slowness, with call counts, P50/P95 resolution times, and direct links to detected issues. Click any component to navigate to the exact issue and start investigating the root cause.

P50 and P95 metrics across the Console

Percentile-based metrics (P50 and P95) now replace the previous min/max values across all views, including the Issues list and Screen Rendering table. This gives a more accurate picture of real-world performance by highlighting tail latency.

Impacted screens in Issue Details

The Issue Details page now shows impacted screens alongside impacted user sessions, allowing you to analyze issues from either the issue or the screen perspective.

Other improvements

• Improved breadcrumbs across all pages showing app name and proper navigation hierarchy
• Automatic Sandbox login (replaces the previous login form)
• Added new app examples in the Sandbox: Android, Android Compose and Compose Multiplatform
• Migrated icon system and updated UI styling across navigation and tabs

March 3rd, 2026 - Koin IDE Plugin 1.5.3

This is a maintenance release addressing numerous issues reported over the past few months, with improved stability, faster indexing, and compatibility with the latest IDE versions.

Faster configuration updates and indexing

The Koin Configuration tree now updates near-instantly after small file edits, with more reliable tree population overall. Background indexing is faster in large projects, with fewer unnecessary full rebuilds. More Koin declarations are recognised on project open, before indexing completes.

Searchable application selector

The Application selector in the Insights tool window now shows a searchable popup with detected apps grouped at the top for faster navigation. Application auto-selection works more reliably, including when multiple projects are open.

Better Koin Annotations and DSL support

• Improved scoped definitions parsing: Better parsing for scoped definitions and scope containers in Koin Annotations, including support for @KoinWorker.
• More accurate DSL detection: Koin DSL detection and gutter icons are now more accurate, especially for imported calls and receiver DSL patterns.
• Gutter icons for typed declarations: Gutter icons now appear in more constructor scenarios.
• Smarter dynamic parameter resolution: Especially for scoped definitions and usages.
• More accurate ViewModel detection: Android ViewModel delegates (activityViewModel, fragmentViewModel) are now detected more accurately in navigation and gutter features.

AI-Assisted issue analysis

AI prompts for performance problems now include cleaner dependency graphs and more precise timing summaries. Crash analysis prompts include more accurate dependency chains. Critical issue filtering uses the latest taxonomy from the Kotzilla backend for more reliable results.

Stability and compatibility

• Compatibility with IntelliJ IDEA 2026.1 and newer IDE versions.
• Fewer false error popups during smart mode transitions and when editing files while indexing is in progress.
• Smoother sign-out flow with no disruptive error popups during session transitions.
• Multi-project support: SDK status now correctly reflects the active project when multiple projects are open.
• Reliable background refresh: issue data in the Insights panel now refreshes reliably in the background.
• Mutable list bindings now correctly appear in the Configuration tree.
• UI fixes: various rendering and formatting issues in issue tables and labels.

Changed

The automatic SDK setup wizard (Quick Setup) has been removed. SDK configuration is now done through the setup flow in the Kotzilla Console.

February 6th 2026 — SDK 2.0.4

This update introduces major improvements to the Kotzilla SDK for Kotlin Multiplatform projects, enabling unified performance monitoring and crash reporting across Android, iOS, Desktop (JVM), and Web (JS/WASM) targets through a single SDK configuration.

Key additions include automatic iOS crash capture with dSYM symbolication for readable stack traces, the new monitoring() API for consistent initialization across all platforms, and a simplified setup experience.

iOS Crash Reporting (Beta)

Crashes on iOS are now captured automatically using PLCrashReporter, which is embedded directly in the SDK. For readable crash reports with de-obfuscated stack traces, run the following command to enable dSYM symbolication:

./gradlew setupKotzillaXcode

UUID-based caching prevents Debug/Release dSYM collisions, ensuring accurate symbolication regardless of your build configuration. This feature is currently in beta, feedback welcome.

Most Common KMP Targets Coverage (Experimental)

The SDK now supports all Kotlin Multiplatform targets, expanding monitoring capabilities beyond Android and iOS.

Desktop (JVM)

JVM Desktop targets are now supported with full event tracking and crash reporting. This enables monitoring of Compose Desktop applications with the same tooling used for mobile. Mapping file support for obfuscated builds is not yet available.

JS Browser and Node

Compose Multiplatform JavaScript targets (both browser and Node.js) are now supported. In browser environments, crash data persists to localStorage to prevent data loss during page reloads or unexpected closures. Source map support for minified code is not yet available.

WASM Browser and Node

WebAssembly targets for both browser and Node.js environments are now supported, enabling monitoring of Compose Multiplatform applications compiled to WASM. Browser builds use the same localStorage persistence as JS targets. Source map support is not yet available.

New monitoring() API

A simpler initialization approach is now available for all platforms. The monitoring() function is generated by the Kotzilla Gradle plugin and automatically reads configuration from kotzilla.json:

import io.kotzilla.generated.monitoring

startKoin {
    monitoring()
}

This unified API replaces platform-specific initialization patterns. The generated configuration includes compile-time type safety and automatic API key obfuscation (XOR+Base64), improving both developer experience and security.

The analytics() function remains available on Android for backward compatibility, but monitoring() is now the recommended default for all platforms. On JVM, JS, Native, and WASM targets, the analytics {} DSL is deprecated.

Setup Simplification

This release significantly reduces the configuration required to integrate the SDK into your project, helping you get started faster with fewer manual steps.

• Automatic dependency injection - SDK dependencies are now added automatically to your project, eliminating manual dependency declarations. Disable with: kotzilla { autoAddDependencies = false }
• ProGuard/R8 rules auto-included - Required ProGuard and R8 rules are now bundled with the SDK and applied automatically, removing the need for manual obfuscation configuration
• Compose instrumentation enabled by default - The composeInstrumentation option now defaults to true, ensuring Compose-specific monitoring is active without additional configuration. Opt out with: kotzilla { composeInstrumentation = false }
• API key obfuscation by default - Generated configuration files now use XOR+Base64 obfuscation for API keys, improving security without requiring manual setup. Opt out with: kotzilla { obfuscateGeneratedConfig = false }
• Fail-fast on missing API key - Builds now fail immediately with an actionable error message if the API key is missing, replacing the previous silent failure behavior and helping you catch configuration issues early
• Removed settings:
  • keyGeneration task removed and replaced by the automatic GenerateKotzillaConfigTask
  • sdkVersion field in kotzilla.json is deprecated and no longer used

Koin 4.x Required

SDK 2.0.x now requires Koin 4.x or higher. Projects using Koin 3.x must upgrade before updating to this release. This alignment ensures compatibility with the latest Koin features and improvements. See the migration guide for detailed upgrade steps.

Compatibility Updates

Dependency	1.4.x	2.0.x
Kotlin	2.0.21 – 2.1.20	2.1.0 – 2.3.0
AGP	8.0 – 8.13	8.4.0 – 8.13.0
Gradle	8.0 – 8.13	8.6 – 9.3
Koin	3.5+	4.0.4+
Compose Navigation	2.9.0-beta01	2.9.1

Bug Fixes

• Fixed API 21 crash in Compose SDK: Resolved an issue where the forEach method caused crashes on devices running API level 21, ensuring compatibility with older Android versions.
• Reduced and optimized SDK traffic: Network communication has been optimized to reduce bandwidth usage and improve efficiency when sending events to the Kotzilla platform.
• Improved reliability of mapping/dSYM upload: Upload processes for Android mapping files and iOS dSYM files are now more robust, reducing failures during build and release workflows.

Known Limitations

• AGP 9.0.0 is not yet compatible, use AGP 8.x for now
• Navigation 3 is not supported. Navigation 2.x continues to work

December 29th, 2025

This update introduces new capabilities and improvements in the Kotzilla Platform, including the Console (3.17.0), SDK (1.4.2), and a new Sandbox environment to help you investigate issues with the right context and understand event correlations for accurate root-cause analysis.

Kotzilla Console 3.17.0

Dashboard and issues views: navigation & prioritization

• Min / Max issue duration available in Dashboard and Issues views
  Each detected issue now includes its minimum and maximum duration (in milliseconds), providing a time-based perspective alongside the number of impacted user sessions.

  

  This applies to both critical and non-critical issues. High minimum or maximum durations can indicate freezes or ANRs, helping you prioritize issues that may have a major impact on user experience, even if they affect a smaller percentage of sessions.

  

• Direct access to the last impacted session
  In both Dashboard and Issues views, hovering over an issue shows the Last Impacted Session” button.

  This provides direct access to the timeline of the most recently impacted session without opening the Issue Details view and manually filtering sessions, reducing the steps required to start root-cause analysis.

  

Timeline View redesign

• Focus on the right context
  The Timeline view has been redesigned as it had become increasingly crowded over time. The new design reduces visual complexity and emphasizes the events that are most relevant for diagnosing issues, helping you to focus on the right context for accurate root-cause analysis.

  

• Timeline slider with explicit event categories
  The Timeline slider now differentiates performance issues and crashes detected by the platform and screen-related events (i.e, Activities, Compose Navigation).

  These elements are clickable, allowing direct navigation to critical moments within a session, which speeds up investigation and improves focus on high-priority events.

• Memory and threading views with reduced noise
  The Components Memory Usage and Events Per Thread views now highlight selected event types (i.e, Koin resolutions, manual traces), while less relevant events are grouped under “Other”.

  This helps concentrate on the information that matters most for understanding session behavior and identifying root causes. Interactions between these views and other Timeline components have been updated to maintain alignment during navigation.

• Event Details view rework
  The Event Details section has been reorganized to reduce duplicated information with the Dependency Graph view and make investigation paths clearer.

  Labels, icons, colors, and default sizing have been updated accordingly, improving clarity and helping users quickly identify relevant events during analysis.

Other console improvements

• Unified message for expired data in Dashboard, Issues, and Sessions views
• Home Page now displays total sessions, events analyzed, and the date of the last recorded session for each app
• Package name now allows uppercase letters during the app registration in the Console

Sandbox environment

A Sandbox is now available to explore the Kotzilla Console’s main capabilities, such as app vitals and critical issue detection dashboards, or to share with your team before integrating the SDK into your app.

• Sample application with multiple versions
  The Sandbox is accessible from the kotzilla.io website and uses pre-collected data of a sample version of the Now In Android app presented during recent DroidCon workshops.

  

  The application includes multiple versions that demonstrate the resolution of different issues (i.e, crashes, performance problems) over time.

  

• Multiple device types
  Sessions are captured from both mobile phones and tablets to illustrate monitoring across different device categories.

Kotzilla SDK 1.4.2

The Kotzilla SDK 1.4.2 includes fixes and updates related to Compose-based projects:

• Handling of multiple generated resource folders
  Fixes a case where generated resource keys in CMP apps were not resolved correctly when multiple resource folders were present.

• Event reporter race condition
  Prevents a race condition that could result in duplicate event batches being sent to Kotzilla.

• Compose app version handling
  Prevents stale app version values from being reported in Compose applications.

• Automatic app version resolution The SDK now resolves and applies the app version automatically for Compose-based applications.

November 17th, 2025

Kotzilla SDK 1.4.0

This SDK release improves platform compatibility, reduces binary size, and avoids library conflicts by removing the Ktor HTTP client.

Kotlin compatibility updates

• Updated minimum Kotlin version to 2.0.21
• Tested and verified compatibility up to Kotlin 2.1.20

Better ProGuard/R8 support

• Added consumer rules to simplify integration and reduce build issues

Native HTTP Client

• The SDK now uses platform-native HTTP implementations instead of Ktor
• Avoids conflicts with apps using their own Ktor versions
• Results in ~500-700 KB non-minified binary size reduction

November 6th, 2025

This latest update makes Kotzilla’s Console, Plugin, and SDK more intuitive to use, resilient, and aligned with latest Koin and Kotlin practices (including support for Koin Annotations 2.2 in the Plugin and Kotlin 2.1.20 compatibility in the SDK)

Kotzilla Console 3.16.0

The new Console introduces a cleaner interface, smarter navigation, and improved visual context:

Contextual navigation in all pages

Dedicated breadcrumbs and inclusion of the application name on each relevant page make it easier to keep track of context when managing multiple apps.

New Dashboard insights

Each critical issue now shows when it was last seen, the percentage of impacted sessions (with a visual representation), and a direct option to generate a prompt for faster AI-assisted fixes.

Onboarding icons by app type

When registering a new app and configuring the SDK, you’ll now see distinct icons and labels for each app type (Android, Android with Compose, Kotlin Multiplatform (KMP), Compose Multiplatform (CMP), and SDK Library) making it easier to identify your setup during the whole process.

General interface updates

• The sign-up page has been redesigned to match the updated look and feel of the new Kotzilla website
• Added an “Age” column in the Issues View for better issue triage.
• Improved refresh logic: issues, sessions, and data consumption now refresh automatically only when returning focus to the Console.

Koin IDE Plugin 1.5.1

The Plugin now supports Koin Annotations 2.2, with full JSR-330 annotation capabilities. This makes it easier for developers to adopt Koin when migrating from frameworks like Hilt and also provides full compile-time safety.

Supported annotations include:

• @Singleton, @Inject, @Named, @Qualifier, and @Scope from both jakarta.inject and javax.inject.
• Works on both class-level and constructor-level (e.g., class Foo @Inject constructor()).
• Adds Android scope archetypes: @ActivityScope, @FragmentScope, @ViewModelScope, and @ActivityRetainedScope.
• Introduces the @KoinApplication bootstrap annotation with correctness validation (enforcing one per module).
• New validation inspections for: Android scope usage, JSR-330 correctness, Configuration alignment, @KoinApplication uniqueness
• The Tree View now displays JSR-330 qualifiers, scope archetypes, and configuration contexts.

Improved issue filtering and inspections

• Critical issue filtering now matches the Console: filter Critical or All issues directly from the Application Issues tab in the Koin Insights view.

• All inspections and checks are now disabled by default, with annotation inspections added to the toggle inspection menu for activation or deactivation.

Kotzilla SDK 1.3.0

The new SDK release improves reliability and compatibility with Kotlin 2.1.20:

• Removed kotlinx-datetime dependency to prevent version conflicts.
• Upgraded Kotlin compatibility to 2.1.20.
• Improved connection and event retry strategies for more resilient error handling in production environments.

September 22th, 2025

Fixing app issues quickly and reliably means identifying critical problems early, reducing downtime, and keeping your users happy.

The latest Kotzilla Platform release helps with that:

• It automatically identifies the most critical issues, such as crashes or ANRs affecting users, and generates ready-to-use prompts with the exact context your AI coding assistant needs, so you can prioritize and resolve them up to 5x faster in production.

• It’s now available for any app or SDK built with Kotlin and Koin, including Compose Multiplatform, making it easier to start monitoring and fixing issues quickly while ensuring consistent coverage across all projects.

Kotzilla Console 3.14.0

Kotzilla Console 3.14.0 introduces contextual AI prompts, Compose event visibility, and a redesigned onboarding flow, providing improved insights and faster resolution of critical issues.

Contextual AI Prompts

You can now generate AI-powered contextual prompts directly from all main Console views: Dashboard, Issues view, Issue Details, and Timeline.

Prompts include:

• Issue type (crash, ANR, other performance issue)
• Impacted components and sessions
• Dependency resolution chain and statistics
• Performance insights and recommendations
• Additional context such as factory type, bindings, and related components

Prompts can be visualized, refined, and copied to your preferred AI coding assistant (Copilot, Gemini, Claude Code, etc.) for rapid root cause analysis and accurate fixes.

New Onboarding Experience

We’ve completely redesigned how you register apps in the Console. When creating a new application, you now simply provide:

• Application name
• Application package

You then select your app type, and the Console guides you through the right setup steps for that environment. Supported types include: Android, Android with Compose, Kotlin Multiplatform (KMP), Compose Multiplatform (CMP) and SDK Library for Android

There’s no longer any need to specify whether your build is debug or release. For release builds, the Kotzilla Gradle plugin automatically uploads the mapping file required to de-obfuscate production data.

If you’ve disabled automatic uploads or want to replace a mapping file, you can still manage them manually in your app’s Settings menu:

• Upload a new mapping file for a specific version after generating it locally
• Delete or replace an existing mapping file as needed

You will find all the details in the Mapping files for production builds section in the documentation

Compose events in the Timeline view

The new kotzilla-sdk-compose library adds full visibility into Compose apps:

• Tracks Compose UI events and navigation events, including arguments.

• Visualizes these events in the Console timeline alongside Android activity and fragment events.

• Supports Compose Multiplatform projects, enabling monitoring across multiple environments.

• Provides a unified view of runtime behavior across all supported app types.

  

Kotzilla Plugin 1.4.0

Building on the platform’s new AI contextual prompts capability, the Plugin now integrates these prompts directly into Android Studio, making it easier to act on issues and apply fixes without leaving the IDE.

AI-Powered prompts for performance issues and crashes

The Application Issues tab in the Koin Insights view now proposes ready-to-use AI prompts for each detected issue, so you can immediately act on problems without leaving the IDE:

• No need to switch between the Console and the IDE to take advantage of AI-assisted debugging.

• Supports AI coding assistants like GitHub Copilot, Gemini, Claude Code, AI Assistant, or Junie.

  

• "Agent" mode is recommended; providing full project context maximizes the accuracy and relevance of AI fixes.

  

AI-Powered prompts for configuration issues

In addition to generating prompts for app issues, the Plugin now supports prompts generation for compilation safety related issues directly in the Configuration Issues tab of the Koin Insights view.

For example, if a Koin dependency is missing from a module, the Plugin generates a detailed AI prompt that includes:

• Issue type, severity, and location in the project
• Parent and dependent components
• A clear description of the issue
• Analysis of common causes, such as missing module declarations or incorrect qualifiers
• Assistant instructions to generate the proper Koin module declaration, including syntax, imports, and dependency injection setup

Kotzilla SDK 1.2.2

This release introduces a new SDK version specifically for apps using Compose: the kotzilla-sdk-compose library, with improvements in Compose instrumentation:

• Simplified CMP project setup
• Automatic tracking of navigation arguments
• Navigation events captured via Kotlin Compiler instrumentation (Compose 1.7+)
• Gradle task checks for Compose resources to ensure smooth CMP integration

Combined with the Console Timeline view, this gives you and your team full visibility into Compose app behavior, complementing existing Android monitoring.

September 11th, 2025

Kotzilla Console 3.10.0

Kotzilla Console 3.10.0 introduces a new issue prioritization system, including email notifications for critical issues, and a new memory graph in the Timeline view to help you analyze problems faster and focus on those impacting your users the most.

Issues Prioritization

Based on your feedback, we improved the way the platform automatically identifies the most impactful issues. This ensures you can prioritize problems affecting your users and focus first on fixing issues that negatively impact your app’s performance and reputation.

Issues are now categorized into two main groups:

• Critical Issues: Issues detected by the platform in the following categories: slow startup, main thread performance, background thread performance, or crashes.

  

• All Issues: Includes critical issues as well as other types like dependency performance, child dependency performance, or dependency complexity.

  

In both views, issues are sorted by the number of impacted user sessions for a particular version, helping you quickly identify problems affecting the largest portion of your users. Both views also include the complete list of issues, with filtering options by app version, issue type, impacted class, and full-text search across properties.

Dashboard view enhancements
This view has also been updated to show only critical issues, along with the number of impacted user sessions and the percentage of affected users for that app version.

Email notifications on critical issues

A new Notification Center is now available for managing email notifications directly within the console. Integration with other systems such Slack will follow in future releases.

• Critical issue notifications
  Admins can enable or disable notifications on new critical issues detected, ensuring that teams are only alerted to the most important problems.

• Flexible scheduling
  Choose how frequently notifications are sent, from every 15 minutes up to once a month, giving you full control over alert frequency.

• Other email notifications
  App Created and Quota Exceeded notifications are also available alongside the critical issue notifications, allowing you to keep track of newly monitored apps by your team and monitor usage of the platform versus the maximum events in your plan.

  

New memory graph in the Timeline View

The Timeline view now features a memory graph, replacing the previous instances creation view. It provides a clear visualization of components’ memory usage throughout a user session, helping you spot patterns and potential issues more quickly.

You can also click on the graph to get additional details:

• Components currently in memory: See which components are active at any given moment.
• Components created during the session: Track new component instances and their lifecycle.
• Open scopes: Monitor ongoing scopes to detect leaks or unexpected behavior.

With this detailed insight into memory behavior, you can analyze issues more effectively, accelerate debugging, and make informed decisions to improve app performance.

Other Improvements

• If you need help to analyse or fix performance issues detected, you can contact our experts directly using the dedicated section available on all pages.
• You can now add notes to an issue in the Issue Details view and display them across other views.
• Views now update automatically after a page refresh in the browser, which is particularly useful when analyzing new user sessions in real time.

Kotzilla SDK 1.2.2

This release includes stability improvements, enhanced logging, and new tracing capabilities.

• Analytics/Koin logger guard at start
  Validates the Koin configuration when the SDK starts, preventing conflicts between different loggers during setup and ensuring consistent event reporting.

• Fixed event emitting & parallelism
  Addresses issues where events could be lost or misordered in parallel operations, improving the accuracy of your analytics data.

• Default push interval updated to 30s
  Optimizes the default interval for sending SDK data, balancing timely reporting with reduced overhead on app performance.

• SuspendTrace support
  Enables tracing of coroutines functions, compatible with Koin Annotations 2.2 and the @Monitor annotation, providing deeper insight into asynchronous operations and performance.

• Improved stability and event handling Fixed core internals and scheduler threading, and improved event handling with better retry strategies.

Koin IDE Plugin 1.3.3

Koin IDE Plugin 1.3.3 introduces major improvements across all tool windows, making it easier to explore your project configuration and identify and resolve issues faster.

• Updated views for configuration and app issues
  Every tool window has been enhanced for better context and usability. The Configuration view now clearly shows the impacted file alongside the subject and description, while the Application Issues view highlights performance and crash issues with all relevant metadata.

  

• Rich filtering and grouping options
  The configuration tree now supports advanced filtering and grouping to help you navigate large projects efficiently. You can filter by:

  • Gradle module
  • Module type (e.g., Android, JVM, KMP)
  • File
  • Declaration type (class, interface, object, etc.)
  • Or view all elements as a flat list for quick access

  

• Code highlighting for Kotzilla issues
  When you click on a performance issue or crash in the plugin, the corresponding impacted component is highlighted and opened directly in the editor. This tight integration reduces context switching and helps you fix issues quickly.

  

• Improved usability and insights
  Additional enhancements include better tree navigation, two-way synchronization with the editor while preserving focus, and a more responsive interface when working with large projects.

July 25th, 2025

Koin IDE Plugin 1.3.1

The Koin IDE Plugin 1.3.1 is now available! This release introduces major improvements to the Koin Configuration and Koin Insights views, enhancing usability for performance debugging and app monitoring.

Koin Configuration View

• Project tree search
  Search elements in your project configuration tree by just focusing the view and start typing, or use Ctrl+F / Cmd+F.

• Two-way navigation with focus preserved
  Navigation is fully synchronized between the Koin project tree and the editor but the editor no longer grabs focus automatically

• SDK status check for Performance Monitoring
  A real-time check on startKoin verifies whether the Kotzilla SDK is properly set up. If it's not, you’ll be guided through a quick configuration process to start monitoring and debugging app performance.

  

Koin Insights & Performance Monitoring

• Improved Flight Checks onboarding
  The Configuration View now opens the Kotzilla Flight Checks tab by default, showing setup options based on your project type.

  For Android apps, you’ll see two buttons: Quick Setup and Manual Setup.

  • Quick Setup uses a graphical wizard to automatically configure your app with the Kotzilla SDK.
  • Manual Setup takes you through a step-by-step onboarding flow.

  

  If a Kotlin Multiplatform (KMP) project is detected, only the Manual Setup option will be available.

• Quick Setup support for Gradle Version Catalog
  The automatic setup wizard uses Kotzilla SDK version 1.1.0 and includes full support for Gradle version catalogs configuration for Android apps.

• SDK data verification and user session insights
  This view now includes real-time verification that user session data is properly captured and transmitted, helping you validate your end-to-end SDK setup. Additionally, the latest recorded user session information is displayed in the Performance Monitoring tab, providing real-time insights into session activity.

  

• Quickly identify and manage apps performance
  The list of apps now shows all apps configured with the SDK for debugging and performance monitoring. Each entry includes build type and package name information, helping you quickly identify the correct app, especially when managing multiple configurations.

  

Bug fixes and stability

• Fixed a crash affecting IntelliJ IDEA users without the Android plugin installed.
• Resolved intermittent logout issues affecting some users.

Kotzilla Console 3.4.0

This month’s Kotzilla Console 3.4.0 update delivers new insights and enhancements across multiple views to help you better understand app behavior and resolve issues faster.

Timeline View

• Dependency Graph View with diagnostics
  Now includes automated analysis and actionable recommendations to pinpoint slow dependency resolution or component initialization issues.

  

• Clickable component rows
  Component rows are now fully interactive when event dependencies exist, and the entire row is clickable to open the dependency graph of the component you want to analyze.

• Custom traces support
  Visualize custom session events using traces, logs, and issues added via the Kotzilla SDK API to help you investigate with more detailed timeline information

  

Issue Details View

• Fix suggestions and documentation links
  Each issue now includes contextual recommendations and direct links to documentation to help you resolve it faster. For every issue, the link provides information about:

  • What it means and how it affects your app’s behavior
  • Why it matters for your users’ experience
  • Practical tips to fix it based on Kotlin and Koin development best practices

  

User Sessions View

• Standardized event metrics
  The total number of recorded events per session is now displayed consistently across all views, making it easier to manage and track usage across your organization.

Dashboard View

• Release Comparison enhancements
  The updated Release Comparison view allows you to visualize component changes between app versions, making it easier to track regressions and improvements over time.

  

As always, we welcome your feedback to help us continue improving the Kotzilla Platform!

June 25th, 2025

Koin IDE Plugin 1.2.0

The Koin IDE Plugin 1.2.0 is now available to download. This release improves configuration safety checks, expands DSL and framework coverage, adds SDK Status checks to help debug and improve app performance, and gives you greater control over how inspection results are displayed.

Configuration safety improvements

We’ve enhanced the plugin’s ability to catch misconfigurations early by extending checks to more advanced usage patterns:

• Dynamic parameter support
  Recognizes dynamic parameter usage in Koin declarations and component resolutions using parametersOf, and integrates them into safety inspections

• Scoped usages (initial support)
  Adds foundational support for analyzing scope declarations and scoped definitions.

• Generic type resolution
  Improves inspection accuracy by better resolving generic types in definitions and injections.

• ViewModel usage detection
  Expands support for handling for different ways of ViewModel usages

• Bindings support rework
  Deep improvements to how bindings are validated, helping detect missing or ambiguous interface-to-implementation mappings.

Broader DSL and framework coverage

• Ktor DSL support The plugin now recognizes Koin declarations and usages inside Ktor DSLs.

• androidContext and androidApplication support
  These Android helpers are now properly resolved in inspections and type checks.

• Expanded DSL methods
  Supports more of the Koin DSL surface, improving coverage for both classic and constructor-based styles.

Dynamic inspections configuration and gutter controls

You now have greater flexibility in how static inspections and navigation elements are displayed:

• Toggle specific inspections
  Enable or disable inspections such as unused definitions or undeclared usages.

• Granular gutter icon controls
  Choose which gutter icons to display:

  • Enable or disable usage, declaration, and parameter icons individually.
  • Optionally restrict icons to show only within constructors.

  

• Inline module declaration support
  Modules defined inside startKoin or koinApplication blocks are now correctly inspected and resolved.

Authentication enhancements

• Classic login flow
  A fallback login method using username and password is now available for users unable to use OAuth-based authentication.

Check SDK Status to debug and improve app performance

To help you identify and resolve performance issues in your Kotlin apps faster, the plugin now checks in real time whether the Kotzilla SDK is properly configured:

• SDK status check in real time You’ll see an indicator in the Koin configuration view and in the code panel that confirms whether the SDK is correctly set up for debugging.

• Quick access to Flight Check If the SDK isn’t configured, click the indicator to open the Kotzilla Flight Check tab. It gives you a full overview of your Koin and Kotzilla setup and helps you complete the SDK configuration step-by-step.

This version also includes various bug fixes, performance improvements, and small UI refinements based on your feedback. Thank you for helping us continue to evolve the Koin IDE Plugin!

June 12th, 2025

This month’s Kotzilla Platform update helps you get from issue detection to resolution faster. The redesigned Timeline View in Console makes it easier to investigate root causes in a single, interactive screen. We’ve also improved SDK setup and added new documentation with practical guidance to fix issues flagged by the platform.

Kotzilla Console 2.1.0 - A new Timeline, built for faster issue resolution

Based on your feedback, we’ve released a new version of the Timeline View designed to make it faster and easier to investigate the root causes of issues by bringing together all the key data you need in a single screen.

The view is organized into three main sections:

1.- Overview of key user session moments

Positioned at the top, this interactive timeline slider summarizes key moments from the session: screen transitions, crashes, and issues detected by the platform. By default, the view spans the entire session duration, giving you full context from the start. You can zoom in on specific segments, and the two panels below will automatically update to reflect your focus area

2.- Session activity graphs

The left-hand side panel displays visual representations of what happened during the session, including:

• Dependency resolution graph: Tracks how many dependencies were requested and created over time.
• Thread execution timeline: Maps key event execution across different threads in your app, helping identify UI thread pressure, background work, or potential threading issues.

This panel also includes two additional tabs:

• Session summary: Displays device model, OS version, app version, and session creation date.
• Session properties: Lists custom properties you’ve added to the session using the Kotzilla SDK API, such as user preferences or current app settings to provide extra debugging context.

3.- Detailed event insights

On the right, you’ll find in-depth events data for the user session, including:

• The full sequence of events that occurred during the session, such as component and dependency resolutions, resolution types, bindings, and related metadata
• Issues flagged during the session, tied directly to the affected components or dependencies

A dedicated tree graph view displaying child nodes for each component resolution event, allows you to visually explore dependency hierarchies and see graphically which dependency resolutions are taking more time

All three sections are fully interactive: zooming or selecting events in one area dynamically updates the others, allowing you to drill down into specific time ranges, filter by event types, and continuously refine your investigation as you trace issues to their root causes.

In addition to that, when you’re analyzing an issue via the Issues View, clicking into a specific user session opens the Timeline already focused on the exact moment and context where that issue occurred. This makes root cause analysis faster and more intuitive.

Kotzilla SDK onboarding improvements

We’ve made the SDK setup experience even smoother:

• Version Catalog support If your project uses Gradle Version Catalog to manage dependencies and plugins, the onboarding wizard now includes full support. A new tab has been added specifically for this setup. You’ll also find step-by-step instructions in the documentation.

  

• SDK Configuration Verification

  At the end of the onboarding flow, you’ll now see a real-time verification step that checks whether your SDK setup is working correctly. This ensures you’re sending data from your first sessions so you can immediately begin debugging and monitoring your builds.

  

Documentation – Issue resolution recommendations

We’ve added a new section in the documentation to help you understand and resolve issues detected by the Kotzilla Platform. For each type of issue, you’ll now find:

• What it means and how it affects your app’s behavior
• Why it matters for your users’ experience
• Practical tips to fix them based on hashtag#Kotlin and hashtag#Koin development best practices

Stay tuned for more improvements, and as always, we appreciate your feedback!

May 15th, 2025

This month’s Kotzilla Platform update delivers important improvements that align with the priorities shared in the Q2 2025 Kotzilla Platform roadmap:

• Koin IDE Plugin 1.0.9 with greater control over configuration checks, a more reliable automatic SDK setup experience for Android apps, expanded inspection coverage, and a lot of improvements to plugin usability
• Kotzilla Console 1.16.0, now with embedded documentation and scopes events visibility in the Timeline view

Koin IDE Plugin 1.0.9

The Koin IDE Plugin 1.0.9 is now available to download. It includes the following improvements:

Extended static configuration safety

In version 1.0.9, we focused on improving static configuration safety by adding support for new use cases that help detect misconfigurations more accurately. In particular, we worked on:

• Qualifier resolution
• Parameter injection
• Inline module declarations inside koinApplication blocks

These additions extend the plugin’s static safety checks across a wider range of Koin DSL scenarios, including:

• startKoin and koinApplication blocks
• Classic DSL and constructor-based DSL
• Qualifier and binding resolution
• Compose API integration

Toggleable configuration safety inspections

You can now disable individual static inspections within the plugin, such as warnings for unused definitions or undeclared usages. This is particularly useful when working with dynamic Koin configurations like dynamicParameters, lazy modules, or generics, which are not yet fully supported in the current implementation. This change helps avoid unnecessary false positives while maintaining relevant checks.

User experience and authentication improvements

This release introduces several UI and UX enhancements aimed at making the plugin easier to use and more consistent during onboarding and everyday development. These include a redesigned set of plugin and gutter icons, a more informative Koin Insights panel when you are not authenticated, and clearer descriptions when no data is available in the Configuration or Application Issues views.

We’ve fixed different issues related to authentication. The plugin now remembers your login state between sessions, and sensitive data is stored using a custom encrypted storage solution instead of relying on keystore-based persistence. A fallback authentication mechanism is also now available, allowing you to sign in directly from within the plugin if the primary method fails.

SDK Wizard improvements

The SDK Wizard, introduced in version 1.0.5, simplifies the process of setting up the Kotzilla SDK in Android projects. In version 1.0.7, we’ve resolved a limitation where the wizard incorrectly appeared in some Kotlin Multiplatform (KMP) projects. The wizard is now properly scoped to Android-only projects while we continue to expand support for KMP.

In the meantime, you ca setup the Kotzilla SDK with your KMP app using the step-by-step configuration guide for KMP available in the documentation.

This version also includes a number of bug fixes and smaller enhancements based on your feedback!

Console 1.16.0 improvements

Embedded documentation in Console views

The latest Console 1.16.0 release introduces embedded documentation links directly into the main views: Dashboard, Timeline, Issues, Issue Details, and Sessions. These context-aware links guide you to the relevant sections of the documentation, making it easier to understand what you’re seeing and how to take action.

Scope events visibility in the Timeline

Scopes in Koin are a powerful way to manage the lifecycle and memory of your objects. However, when left open or misused, they can result in unintended memory leaks. To help identify and resolve these issues more effectively, Console 1.16.0 introduces scope events and contextual indicators directly within the Timeline.

These updates make it easier to trace the origin of leaked scopes or improperly reused instances, giving you the visibility needed to prevent memory issues and improve your app’s stability.

April 17th, 2025

This month Kotzilla Platform update brings some big improvements across the board, including:

• Koin IDE Plugin 1.0.5 with SDK Installation Wizard
• Kotzilla Console 1.12.0 version that now supports issue categorization, severity levels, and release comparison
• New Gradle Version Catalog setup guide for the Kotzilla SDK 1.0.1

Koin IDE Plugin 1.0.5 Released

The latest version of the Koin IDE Plugin introduces the following new capabilities and improvements:

Support for qualified Koin declarations

We’ve expanded our static checks to include qualified Koin declarations and usages. This is part of our ongoing effort to improve configuration checks across Koin DSLs.

False positive fixes

Thanks to community feedback, we’ve resolved a number of false positives during the config checks that were being flagged as warnings in previous versions. We also improved support for binding declarations and a lot of minor improvements, fixes, and optimizations.

Keep the reports coming, it’s helping us refine this experience for everyone!

New Kotzilla SDK installation wizard

A major new addition is the SDK Wizard, available now for Android projects. If your project is compatible, you’ll see a new “Install SDK” button in the "SDK" tab within the Koin Insights view of the plugin.

This tab will provide you information about your current Koin version, the latest SDK version, your app's package ID as well as links to manual setup guides for Android apps, KMP apps and libraries if the installation wizard can not be used.

The SDK Wizard will ask you to insert a app name and specify the package id. It'll then automatically do the following steps for you:

• Adds the Kotzilla Gradle plugin to your root build.gradle
• Configures your app’s build.gradle with default SDK setup
• Creates a kotzilla.json with your app's API key
• Adds the analytics() call to your Application class

Once setup is complete, sync and run your app to capture your first user session right away.

Kotzilla Console v1.12: new dashboard and filters for issues prioritisation

The Console received a significant upgrade in version 1.12, introducing better ways to categorize, compare, and prioritize issues affecting your users.

Categorization of issues by type

Your app’s Dashboard View now includes a pie chart categorizing last 15 issues into:

• Crashes: explicit unhandled errors or hard crashes in your app
• Performance: slow startup, delays in resolving components and dependencies, and main/background thread blocking.
• Architecture: complex dependency graphs that could impact maintainability and scalability of your app

Each issue also includes details on impacted app versions and user sessions, helping you understand scope and priority.

Severity levels for better prioritization

We’ve added a severity classification system that automatically groups issues into Critical, High, Medium, and Low, based on an algorithm inspired by the Apdex methodology. It evaluates how far an issue deviates from its defined target and tolerance, giving you an objective way to identify high-impact problems.

Version performance comparison

You can now compare different versions of your app to assess regressions or improvements. Comparisons include:

• Total user sessions
• Number of issues detected
• Number of affected devices
• Average user session duration

Just select the builds you want to compare, and the Console will do the rest.

Two ways to explore issues: by issue type or class impacted

We’ve expanded how you can navigate and make sense of issues in the Console by introducing two complementary views:

• "All Issues" View: Our existing view has been enhanced with Severity visualization, allowing you to prioritize issues based on impact (Critical, High, Medium, Low).

• "Issues by class": This new view groups detected issues by the classes they impact, giving you the details of which components or dependencies (ie. ViewModel, ListenableWorker, DataRepository) are generating the most problems.

Together, these views give you both granular control and broader insights so you can triage, debug, and improve more efficiently.

Issue Details view updates

The Issue Detail View now highlights the most relevant information:

• Issue category: Quickly see whether the issue is related to Crash, Performance, or Architecture.
• Slow resolutions: For performance-related issues, you'll now see how long it took to execution of a specific componennt or dependency.

Side drawer for issues in the Timeline View

The Timeline View now includes a side drawer showing a summary of each issue detected during a user session. This helps you quickly assess what happened in a session without diving into full issue details.

Saved filters between views

We’ve improved filter persistence across views. Filters are now saved when navigating back and forth. This is really helpful when you're analyzing large datasets with thousands of sessions and issues across many app versions.

Kotzilla SDK: Version Catalog setup now supported

You asked, we delivered! A lot of you manage your dependencies using Gradle Version Catalogs, and requested clear documentation on integrating the Kotzilla SDK with this setup. We’ve now published a dedicated guide to help you configuring the SDK using Version Catalog

Thanks again for all your feedback!

March 9th, 2025

We’re happy to share with you the latest updates to the Kotzilla Platform

Release of Koin IDE Plugin 1.0.3

The Koin IDE Plugin helps you visualize and manage your Koin configurations and dependencies directly within Android Studio or IntelliJ IDEA. It simplifies code navigation, enhances configuration accuracy, and enables you to catch both configuration and performance issues early in the development process.

Key capabilities include:

• Hierarchical visualization of application dependency structures
• Contextual navigation between components and their implementations
• Koin validation and configuration safety capabilities (Beta)
• Real-time detection of app issues (with Kotzilla SDK integration)
• Root-cause analysis capabilities through the Kotzilla Console

For detailed information on the supported features and ongoing improvements related to Koin configuration validation, check out the full documentation here

Kotzilla Console: Filtering on impacted sessions

We’ve introduced new filtering capabilities in the Impacted Sessions section of the Issues Details View, allowing for a more focused and efficient root cause analysis. The new filters include:

• App version, device model, operating system, and manufacturer
• Full-text search on session properties, timeline components, and logs

These new filtering options enable you to drill down into specific criteria, making it easier to identify and resolve issues based on your app’s context, improving your debugging workflow.

Kotzilla SDK: Automatic mapping files upload

The latest release of the Kotzilla SDK (1.0.1) introduces the ability to automatically upload mapping files for released builds (production builds). This feature now uploads mapping files following any 'assembleRelease' build. You can disable this feature by setting uploadMappingFile = false in the Kotzilla Gradle configuration.

March 4th, 2025

Here are latest enhancements to the Kotzilla Platform, including:

• Issue-type filtering in the Issues View of the Console
• Dedicated tabs in the Dashboard View for focusing on crashes vs. all issues
• A new Plans & Data Usage menu in the console for monitoring your plan and data consumption

Filtering issues by type now available in the Issues View

We’ve expanded the filtering options in the Issues View of the Console. In addition to existing filters (by version and full-text search on content), you can now filter issues by type, including:

• App crashes
• Custom SDK issues
• Performance and complexity issues (i.e, startup performance, main thread performance)

This makes it easier to focus on the issues that matter most to your development process.

Dedicated view for crashes in the Dashboard View

The Dashboard View of the Console now includes dedicated tabs to separate:

• Crashes: A focused view for identifying and resolving crash-related issues
• Open Issues: A complete list of all open issues including performance, complexity, and crashes.

New "Plans & Data Usage" menu in the Console

We've introduced a Plans & Data Usage section under the Settings menu in the Console. This view provides:

• Insights into your current plan as well as an overview on other existing Plans
• The ability to request updgrade to other Plans depending on your team needs

• Weekly tracking of Events and User Sessions data usage

This update makes it easier to monitor your platform usage and manage your subscriptions

Stay tuned for more improvements, and as always, we appreciate your feedback! 🚀

February 21th 2025

We’re happy to share the latest enhancements to the Kotzilla Platform, including:

• The release of the Koin IDE Plugin Beta for Android Studio and IntelliJ
• A refined issue prioritization system based on both urgency and impacted sessions
• User experience improvements in root cause analysis to quickly focus on critical issues
• New version of the Kotzilla SDK that simplifies configuration and that ensures continued data collection even during network downtime
• Documentation updates to include detailed description of key components of the platform, debugging guides and advanced tutorials

Koin IDE Plugin Beta now available

The Koin IDE Plugin is now in Beta and available in the JetBrains Marketplace, for both Android Studio and IntelliJ. This plugin allows you to visualize and manage your Koin configurations and dependencies directly within your development environment, simplifying code navigation, and helping you spot both configuration and performance issues early in the development process.

The Koin IDE Plugin is connected to the rest of the Kotzilla Platform through the Application Issues tab available within the Koin Issues window. Here, you can view the list of your registered apps for debugging and the issues automatically detected by the platform.

The step-by-step installations instructions are available here

Issue prioritization by urgency and impact

We've deployed the first version of our new issue prioritization system, which evaluates both the urgency of addressing an issue and the number of impacted sessions.

For instance, long app startup times or slow components blocking Threads will now score higher in the issues view, allowing you to focus on the most critical problems first. This prioritization is available in both the Application Issues tab of the plugin:

and the Issues View of the console:

UX improvements in root cause analysis

To assist you in quickly identifying issues graphically, we've updated the Timeline View to align the color scheme for key events types (i.e, screen states, Koin resolutions) between the graphical overview and the detailed event sequence. Additionally, different colors are now used to categorize issues in both the Timeline and Issues View of the Console, distinguishing between performance, complexity, and crashes.

Unified onboarding experience

The onboarding graphical wizard allowing you to register new apps for debugging has been enhanced to include dedicated configurations for initializing the Kotzilla SDK across various project types: Android apps, Kotlin Multiplatform (KMP) apps and SDK Libraries:

New version of the Kotzilla SDK

The Kotzilla SDK has been updated with the following enhancements:

• Simplified configuration: You can now start the Kotzilla SDK with a one-line setup in your Android apps using the analytics() function in Koin. The KMP setup has also been simplified using the same function.
• ktor 2 and 3 compatibility: The SDK now supports different versions of ktor (Ktor 2 and Ktor 3) to prevent conflicts between the Ktor library version in your app and the one used by the SDK.
• Network resilience: The SDK is now capable of recovering from network errors, allowing it to resend events if your app goes offline temporarily.

Access the full SDK changelog here

Kotzilla Platform documentation updates

We’ve updated the Kotzilla documentation to provide:

• Detailed description of key components: Koin IDE Plugin, Kotzilla SDK, and the Kotzilla Console.
• Debugging guides: Step-by-step instructions for debugging Android apps, KMP apps, and SDK libraries right in your IDE.
• Advanced tutorials: Learn how to identify and resolve critical app issues using the Koin IDE Plugin and Kotzilla Console.

January 13th 2025

We’re excited to announce the latest updates to the Kotzilla Platform, focused on automatic issue detection and root cause analysis, along with improvements to usability and platform navigation.

Automatic issue detection

The Kotzilla Platform now automatically identifies and displays critical issues of your app without requiring any additional instrumentation of your code. The platform detects and surfaces the following issues:

• Startup performance issues: When the app takes too long to initialize, delaying the first usable screen.
• Background performance issues: Excessive resource usage or slow execution of background tasks, impacting responsiveness.
• Main thread performance issues: Tasks running on the main thread for over 100ms, potentially causing freezes or ANRs.
• Dependency performance issues: Inefficient resolution of dependencies slowing down app responsiveness.
• Dependency complexity issues: Dependency graphs with more than 5 child dependencies, increasing maintenance and performance risks.
• Child dependency performance issues: Individual dependencies taking over 5ms to resolve, causing cascading slowdowns.

Thanks to the Kotzilla SDK, the platform can analyze your app's runtime behavior to uncover these issues. No manual setup or instrumentation is needed, allowing you to focus on resolving problems before they impact your users.

Issue investigation and root cause analysis

We’ve updated key views in the Kotzilla Console to facilitate investigations of issues and crashes, providing better contextual insights and enhanced root cause analysis to help you resolve problems more efficiently:

Issues view

• Detected issues overview: Displays all detected crashes, app issues and custom issues tracked via the Kotzilla SDK API.
• Issues details: Each issue entry includes a description, impacted user sessions, affected versions, and additional details such issues status (open, acknowledged, closed).

• Issues drill-down: You can click on any issue to view detailed information such as stack traces for crashes, or explanations on the cause of the issue for performance, memory and app complexity problems. The issue details view also shows impacted user sessions, allowing you to continue the investigation down to specific user sessions.

Dashboard view

This view now lists detected issues immediately after the app health check overview, ensuring that the most critical issues for any app version are displayed first, allowing you to focus on what matters most.

Timeline view

• Graphical identification of issues: Issues are now visually marked within the sequence of events using flags, making it easier to identify the exact component or action causing the problem in the timeline.
• Contextual navigation from the Issues view: Accessing an issue from the Issues View takes you directly to the relevant event or component in the timeline. You can then expand the tree to continue your investigation, drilling down into further events or related dependencies as needed.

• Full text filtering: You can now filter the sequence of events by category, content, and thread. This includes full-text search capabilities, allowing you to quickly locate specific events or issues within the timeline

Home page updates

We’ve improved the Home Page to make it more intuitive and resourceful:

• Developer resources: Quick access to documentation, the latest Kotzilla SDK versions, and updates on the upcoming Koin IDE plugin.
• Community resources: Links to Get Started guides, feedback channels, Slack, contact forms, and demo booking.
• Revamped app list: An overview of all registered apps with quick access to settings, dashboards, and the ability to register new apps.

These changes provide a better experience for both new users and experienced developers by improving navigation and visibility.

Other improvements

This release also includes additional enhancements to improve usability and functionality:

• Redesigned inner navigation: Includes collapsible views to maximize your analysis workspace.
• FAQ section: Now features a direct link to the FAQ in the Kotzilla Platform official documentation
• Account verification page: A new page prompts new users to verify their account after it has been created.
• User roles in profiles: User roles are now displayed in the profile, providing more clarity on permissions and responsibilities.

As always, we welcome your feedback to help us continue improving the Kotzilla Platform!

November 20th 2024

Cloud-Inject is now Kotzilla Platform

To simplify and strengthen our brand, we’ve renamed Cloud-Inject to Kotzilla Platform, brought to you by Kotzilla; the creators of the Koin framework.

We also have a brand-new company website: kotzilla.io

Enhanced SDK for secure data transfer

The SDK Package name has been moved to kotzilla-sdk and Kotzilla-plugin.

Security just got stronger! Kotzilla SDK 0.13.x release has been upgraded with robust token-based security:

• Private key management: Organizations now require private keys to ensure reinforced security.
• Token generation: Generate private tokens per app using organization keys
• AppKey management: Use the same appKey multiple times across organizations.

Thanks to these enhancements, the same app can now be registered multiple times on the platform. To help you get started, we’ve created a step by step tutorial based on the open-source NowInAndroid repo for Koin, demonstrating how to debug your apps with the Kotzilla Platform.

Additionally, the Kotzilla SDK is now available not only on Maven Central but also in our public Kotzilla Repository, making it even easier to integrate.

Revamped issues view

We’ve completely reimagined the Issues View for better usability and alignment with the Session View

Improved layout: Clearly highlight issue types, impacted user sessions, and statuses.

Advanced filters: Filter by date, type (open/acked/closed), version, and content.

Detailed issue insights: Easily see type, creation/last-seen dates, and impacts within the redesigned issue detail page.

Collaborate on debugging (”Dev Team” and “Enterprise” editions only)

You will never work alone again! You can now invite team members to your organization for collaborative debugging:

Invite members: As an Admin user you can invite users via email to create an account and join your organization.

Role Management: Admins can view roles, track invitations, and manage team access.

Collaborative Access: Invited members can debug registered apps and add new ones collaboratively.

Redesigned left-side menu

Navigation just got simpler! The improved menu now includes:

• Direct access to Settings, FAQ, Documentation, Support, and the Changelog.
• A new “Settings Menu” for Admins to manage platform configurations with ease.

Log in now to explore the new features!**

As always, your feedback is welcome. Let us know what you think!

September 27th 2024

New dashboard component metrics

We’ve added a new section to the Dashboard page that highlights the Top components requested. This section provides useful insights into your components complexity and performance with the following key metrics:

• Component name
• Number of dependencies (both direct and total)
• Average duration time (for both creation and usage)
• Number of classes using the component

This allows you to better understand how individual components are performing within your app.

Instant user feedback

We’ve made it easier to provide feedback. The Slack button has been replaced with a dedicated User feedback link in the footer across all pages of Kotzilla Platform. Now, you can share instant feedback via a simple form, without needing to join a Slack channel.

Application consumption dashboard

A new Application Consumption dashboard has been introduced, offering a detailed analysis of application usage. This view provides weekly insights into the number of sessions and events processed over a particular duration, allowing you to monitor consumption patterns at a glance.

SDK compatibility with Koin 4.0

We’ve updated the Kotzilla SDK to support Koin 4.0, which is built on Kotlin 2.0. This update includes major improvements to the ViewModel API and embraces a fully multiplatform approach. Now, you can integrate Kotzilla Platform seamlessly with your apps that are using the latest version of Koin.

July 7th 2024

New sessions page analytics

You can now see the number of instances requested, the number of events processed, the maximum event duration, and visual analytics about the types of events (e.g., UI events, scope events, or others). This overview enables you to quickly identify which sessions may require further investigation based on these key metrics.

The new Sessions page also includes a chart view that allows you to visualize sessions created by date. You can click on a particular date to drill down into the sessions you want to investigate.

Dashboard redesign to improve user experience

The team has redesigned the Dashboard page to integrate the new sessions view and render the content in a more user-friendly manner. The current update includes three main sections:

• An overview with key highlights of a particular version of an app: sessions analyzed, events consumed, different devices, as well as # issues and crashes detected.
• A list of the latest user sessions and issues for a particular version

Performance and complexity charts have been removed as they were misleading and rarely used

Better support for Kotzilla Platform users

To encourage your feedback and ensure you quickly receive answers to any questions about usage or issues, we've integrated a Slack button in the footer of Kotzilla Platform. This button is visible on all pages of the product.

Simplified onboarding

We're continually enhancing every aspect of our app registration process. For instance, we've streamlined the process from 5 steps down to 4. Additionally, the initial registration page of the wizard has been simplified by removing the confusing "register" button.