Skip to main content

What's new

New updates and improvements to Kotzilla Platform

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 seetings 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:

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.