InsertKoinIO/koin

This release introduces a comprehensive rework of Koin's core architecture, featuring a new 'Koin Fu' DSL for compile-time safe dependency registration, a robust coroutine-based engine for parallel lazy module loading, and a unified ViewModel integration that replaces legacy Android-specific modules. The framework expands its multiplatform support with WebAssembly (Wasm) and Native targets, while significantly enhancing Android and Compose integration through lifecycle-aware scopes, a new Compose context wrapper, and a dedicated Compose ViewModel API. Additionally, the release delivers extensive testing and verification tools, including a new \verify()\ API for static module validation, JUnit 4/5 test rules, and a Gradle plugin for automated module checking, all underpinned by improved error handling and performance benchmarking utilities.

A new Android Compose sample application has been added to the repository, providing a complete working example of integrating Koin with Jetpack Compose. The sample includes an AndroidManifest, a MainApplication to initialize Koin, and a MainActivity featuring Compose UI components. It demonstrates key Koin features such as injecting ViewModels and services, managing scopes, and using isolated contexts, serving as a reference implementation for developers.

examples/sample-android-compose · high confidence

New compatibility classes (GetViewModelCompat, ScopeCompat, SharedViewModelCompat, ViewModelCompat) are added to the Android module. These provide Java-friendly, thread-safe accessors for resolving ViewModels from the Koin container, bridging Android's lifecycle components (Activity, Fragment, ViewModelStoreOwner) with Koin's scope and parameter resolution logic.

projects/android/koin-android-compat/src/main/java · medium confidence

Added new Android performance benchmarking example in the \android-perfs\ module. The \MainApplication\ now runs a performance test using \PerfRunner\ to measure execution times and start times, storing the results. The \MainActivity\ displays these performance metrics (start time, execution time, and pass/fail status) on the screen, using color coding to indicate success or failure.

examples/android-perfs/src/main/java · high confidence

Added new files to support Koin scopes for AndroidX Fragments and Activities. This includes \KoinFragmentFactory\ and \setupKoinFragmentFactory\ to integrate Koin with the Fragment lifecycle, DSL extensions (\fragmentOf\, \fragment\) for defining Fragment-scoped dependencies, and base classes (\ScopeActivity\, \ScopeFragment\, \RetainedScopeActivity\) that automatically manage Koin scopes tied to the Android lifecycle. The \ScopeHandlerViewModel\ is introduced to retain the Activity retained scope across configuration changes.

projects/android/koin-android/src/main/java/org/koin/androidx/scope · high confidence

Introduced KoinInitializer and KoinStartup interface to enable safer, lifecycle-aware initialization of Koin via AndroidX Startup. The new KoinInitializer implements the AndroidX Initializer contract, allowing Koin to be started automatically during application startup. The KoinStartup interface provides a clean way to configure Koin during this startup phase, marked as experimental via @KoinExperimentalAPI.

projects/android/koin-androidx-startup/src/main/java · high confidence

A new AndroidX sample application has been added to the repository, providing a comprehensive set of examples for integrating Koin with Android components. The sample includes activities, fragments, and viewmodels demonstrating various Koin features such as activity and fragment scopes, ViewModel injection, saved state handling, and WorkManager integration. The app showcases dependency injection patterns for MVP and MVVM architectures, custom SDK integration, and navigation graph viewmodels.

examples/androidx-samples/src/main/java · high confidence

The Koin AndroidX Compose module now provides a \koinViewModel\ composable function that resolves and manages AndroidX ViewModels within a Compose tree. This new API allows developers to inject ViewModels directly into their UI components, simplifying state management and lifecycle handling in Compose-based Android applications.

projects/compose/koin-androidx-compose/src/main/java/org/koin/androidx/compose · high confidence

The Koin library now provides platform-specific coroutine implementations for JavaScript and Native targets. For JavaScript, a new \KoinPlatformCoroutinesTools\ object is introduced, which includes a \runBlocking\ function that wraps a coroutine block into a promise and retrieves the result, accompanied by a warning about its experimental status. For Native targets, the \KoinPlatformCoroutinesTools\ object is added to provide a standard \runBlocking\ implementation using \kotlinx.coroutines.runBlocking\. These additions ensure consistent coroutine support across these platforms.

projects/core/koin-core-coroutines/src/jsMain · high confidence

A new JVM-specific extension function, \runOnKoinStarted\, has been added to \KoinWaitExt.jvm.kt\. This function allows users to block the current thread and execute a provided suspend block once all lazy modules have finished loading, providing a synchronous entry point for startup tasks that depend on Koin's initialization. The file also contains a commented-out version of \waitAllStartJobs\, indicating a shift in how these waiting mechanisms are exposed.

projects/core/koin-core-coroutines/src/jvmMain/kotlin/org/koin/core · medium confidence

Added new utility files to the Koin core ViewModel module: BundleExt.kt provides a conversion from SavedState to CreationExtras and defines a SavedStateDefinition typealias; CreationExtrasExt.kt offers a helper to retrieve default CreationExtras from a ViewModelStoreOwner; and GetViewModel.kt introduces internal functions to resolve and lazily resolve ViewModels using the AndroidX ViewModelProvider and CreationExtras APIs.

projects/core/koin-core-viewmodel/src/commonMain/kotlin/org/koin/viewmodel · medium confidence

The Android samples application now includes a Koin configuration file (koin.properties) that sets the app title to "Android Samples Demo". Additionally, a shell script (check\_modules.sh) has been added to the coffee-maker example to verify module integrity via Gradle.

examples/androidx-samples/src/main/assets, examples/coffee-maker · high confidence

Users can now integrate Koin with AndroidX WorkManager. A new KoinWorkerFactory enables dependency injection for background workers, while DSL extensions (Module.worker, ScopeDSL.worker, and workerOf variants) allow declarative registration of ListenableWorker classes. The KoinApplication is automatically configured to initialize the WorkManager factory, allowing workers to be resolved from the Koin container.

projects/android/koin-androidx-workmanager, projects/compose/koin-compose-viewmodel/src/commonMain/kotlin/org/koin/compose/viewmodel, projects/ktor/koin-logger-slf4j · medium confidence

Introduces a new module, koin-compose-navigation3, that provides Koin integration for the AndroidX Compose Navigation 3 library. The module exposes a koinEntryProvider composable function that aggregates all registered navigation entries from the Koin scope, allowing developers to easily inject dependencies into navigation destinations. It also provides a DSL extension for modules and scopes to register navigation entries with optional metadata, supporting both scoped and singleton registration patterns.

projects/compose/koin-compose-navigation3 · high confidence

A new extension function, koinNavGraphViewModel, is added to the Koin AndroidX Navigation library. This allows Fragments to request a ViewModel instance that is scoped to a specific AndroidX Navigation graph, ensuring that the ViewModel is tied to the back stack entry of that graph rather than the Fragment's lifecycle alone.

projects/android/koin-androidx-navigation/src/main/java · high confidence

A new Ktor-based example application has been added to demonstrate Koin integration with Ktor 3. The example includes a main module and a secondary module, showcasing how to inject dependencies within Ktor routing nodes and use request-scoped beans. The setup includes configuration for the Netty server, logging, and a test class that is currently disabled due to failing tests.

examples/hello-ktor · medium confidence

A new sample application demonstrates integrating Koin with Ktor's dependency injection system. The example defines two services (HelloKoinService and KtorSpecificService) and configures them using both Koin's native injection and Ktor's DI plugin. It includes endpoints that showcase using Koin, using Ktor DI, and mixing both within the same application, along with corresponding integration tests verifying each endpoint's response.

examples/ktor-di-sample · high confidence

A new multi-module example application built with Ktor has been added to the examples directory. This includes the main application entry point, a shared service interface, and integration tests that verify the routing and dependency injection behavior across modules A and B.

examples/multimodule-ktor · high confidence

New example applications for Ktor are introduced in the examples/multimodule-ktor directory, demonstrating how to integrate Koin with Ktor. Each module (module-a and module-b) defines a service and registers it with Koin, then exposes an HTTP endpoint that returns a greeting string. This provides a concrete reference for users looking to combine Koin with Ktor in a multi-module project structure.

examples/multimodule-ktor/module-a, examples/multimodule-ktor/module-b · high confidence

A new \verify\ extension function is added to \ModuleConfiguration\, allowing users to validate the configuration of modules and lazy modules. This includes detecting index duplications and verifying dependencies, with support for extra types and injection parameters.

projects/core/koin-test-coroutines · high confidence

New extension functions are added to the Koin core library to simplify the declaration of Android ViewModels. The \Module\ and \ScopeDSL\ now include \viewModel\ and \viewModelOf\ functions, allowing developers to register ViewModels directly within module definitions using compile-time constructor resolution without reflection.

projects/core/koin-core-viewmodel/src/commonMain/kotlin/org/koin/core · high confidence

A new coffee-maker example application has been added to the repository, demonstrating the use of Koin for dependency injection. The example includes a modular setup with components like CoffeeMaker, ElectricHeater, and Thermosiphon, showcasing modern Koin DSL features such as \singleOf\ and \bind\ for cleaner module definitions.

examples/coffee-maker/src/main · high confidence

A new benchmark file (NativeBenchmark.kt) has been added to the nativeMain source set, enabling performance measurement of Koin's dependency retrieval on native platforms. This allows users to track and compare the speed of resolving dependencies in native environments alongside existing JVM benchmarks.

projects/core/benchmark/src/nativeMain · high confidence

Added a new JVM benchmark suite in the core project to measure Koin's startup performance and scope resolution times. The diff introduces four new benchmark classes—HeavyStartupBenchmark, JvmBenchmark, ScopeBenchmark, and StartupBenchmark—using the JMH framework. These benchmarks measure the time taken to initialize Koin with various module configurations (including lazy modules and bind registrations) and resolve dependencies across root and nested scopes.

projects/core/benchmark/src/jvmMain · high confidence

Added a new \examples/jvm-perfs\ directory containing a JMH-based benchmark suite for the JVM. This includes a \BenchmarkClass\ that measures the startup time and execution time for scenarios such as starting 400 singletons, injecting dependencies, and flattening nested module structures. The suite also provides a \PerfRunner\ to execute these scenarios and report average start and execution times in milliseconds.

examples/jvm-perfs · high confidence

A new file, ContextWaitJVM.kt, was added to the Koin core-coroutines module. This introduces a platform-specific implementation for waiting on Koin's start jobs, exposing a waitKoinStart function that delegates to the KoinPlatform's waitAllStartJobs method, ensuring that asynchronous initialization tasks complete before proceeding.

projects/core/koin-core-coroutines/src/jvmMain/kotlin/org/koin/core/context · high confidence

A new API file, \projects/core/benchmark/api/benchmark.api\, was added to the project. This file defines the public API for the \org.koin.benchmark.BindPerfs\ class and its associated inner classes (e.g., \BA1\, \BA2\, etc.), which implement the \IA\ interface. This change introduces the public interface for the Koin benchmarking suite, allowing external tools or tests to interact with the performance measurement components.

projects/core/benchmark/api · high confidence

The Koin test module now includes a new verification API that allows developers to statically validate their dependency injection configurations. This includes the \Module.verify()\ and \List\<Module\>.verifyAll()\ extension functions, along with supporting classes like \ParameterTypeInjection\ and \Verification\. These tools help ensure that all constructor dependencies are properly defined, detect circular injections, and identify missing definitions, providing clear error messages and fix suggestions during testing.

projects/core/koin-test/src/jvmMain · high confidence

New extension functions were added to the Koin plugin's DSL, specifically \viewModel()\ and \buildViewModel()\, which allow users to define ViewModels within Koin modules and scopes. These functions facilitate the integration of Android's ViewModel lifecycle with Koin's dependency injection, supporting explicit class types and qualifiers for more flexible injection strategies.

projects/core/koin-core-viewmodel/src/commonMain/kotlin/org/koin/plugin · medium confidence

New benchmark files have been added to the core benchmark suite to measure the performance of lazy module creation and the \bind()\ registration path. The changes introduce \lazyModule\ and standard \module\ definitions for 400 services each, alongside a separate set of 400 class hierarchies and interface bindings to isolate and profile the overhead of dependency registration and mapping.

projects/core/benchmark/src/commonMain · high confidence

The Koin core library now includes a new \KoinConfigurationHint\ annotation and a suite of compiler plugin stubs in the \org.koin.plugin.module.dsl\ package. These stubs—such as \startKoin\<T\>()\, \koinApplication\<T\>()\, \koinConfiguration\<T\>()\, \withConfiguration\<T\>()\, \module\<T\>()\, and \Scope.create\<T\>()\—serve as placeholders that the Koin compiler plugin transforms into actual module registration code. This enables cross-module discovery of \@Configuration\ annotated classes and allows the compiler to inject modules based on type parameters, replacing manual \T().module\ patterns with type-safe, reified calls.

projects/core/koin-core/src/commonMain/kotlin/org/koin/plugin · high confidence

Added a \CLAUDE.md\ file defining project doctrine, module mapping, and PR guard rules (API compatibility checks, test requirements, and KMP test traps). Added shell scripts (\benchmark.sh\, \benchmark-gc.sh\, \clean.sh\, \compare\_apis.sh\, \install.sh\, \release.sh\, \test.sh\, \test-macos.sh\) to automate common build, test, and release tasks. Moved \gradlew\ and \gradlew.bat\ into the \projects/\ directory and updated their paths. Added \deps.txt\ and \llms.txt\ for dependency and LLM context. These changes provide a standardized workflow for building, testing, and releasing Koin.

projects · high confidence

The Koin core library now includes new time measurement utilities. A new \DurationExt.kt\ file provides a \Duration.inMs\ extension property to convert durations to milliseconds. Additionally, \Timer.kt\ introduces a \Timer\ class for tracking elapsed time in seconds, milliseconds, and nanoseconds, along with a companion object for starting timers. These additions support internal performance measurement and timing operations within the Koin framework.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/time · medium confidence

New platform-specific implementations for the WebAssembly target have been added to the Koin core library. This includes a new KoinPlatformTools file that uses the Kotlin standard library's Uuid class to generate random identifiers, alongside platform-specific implementations for thread-local storage and concurrent collections via the Stately library. These changes enable Koin to function on WebAssembly-based environments.

projects/core/koin-core/src/wasmJsMain/kotlin/org/koin/mp · high confidence

The Android module now includes a suite of new files providing Android-specific Koin functionality. This includes an Android logger (AndroidLogger) that routes Koin logs to the Android Logcat, and extension functions to register the Android Context and load properties from assets. It also introduces scope management for Android components, allowing Activities and Services to create, manage, and destroy Koin scopes tied to their lifecycle, along with a base ScopeService class for automatic scope handling in Android Services.

projects/android/koin-android/src/main/java/org/koin/android · high confidence

The public API surface for Koin's ViewModel integration is now explicitly defined and versioned. This change introduces the API signatures for the \koin-core-viewmodel\ module across Android, JVM, and common targets, exposing classes such as \KoinViewModelFactory\, \ScopeViewModel\, and extension functions like \viewModel\ and \buildViewModel\ for module and scope DSLs. These additions provide the stable contract for resolving and creating ViewModels within the Koin dependency injection framework.

projects/core/koin-core-viewmodel/api · high confidence

The Koin core library now includes a new logging infrastructure. A new \Logger\ abstract class has been added to define the logging interface, supporting multiple log levels (DEBUG, INFO, WARNING, ERROR, NONE) and helper methods for each level. Additionally, an \EmptyLogger\ implementation has been introduced, which provides a no-op logging solution that suppresses all log output.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/logger · medium confidence

The Koin library now exposes the \Scope\ class, which manages instance resolution, lazy injection, and scope linking, along with a \ScopeCallback\ interface to handle scope closure events. This provides the core mechanism for managing the lifecycle and resolution of dependencies within specific scopes.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/scope · high confidence

Added new API to support automatic scope creation and lifecycle management for ViewModels. The \ScopeViewModel\ base class and \viewModelScope()\ extension function allow ViewModels to easily create and manage their own Koin scopes. Additionally, \ViewModelScopeArchetype\ and the \viewModelScope\ DSL block enable developers to declare scoped dependencies that are automatically closed when the ViewModel is cleared, simplifying memory management and dependency injection in ViewModels.

projects/core/koin-core-viewmodel/src/commonMain/kotlin/org/koin/viewmodel/scope · high confidence

Koin now supports loading modules asynchronously in parallel background coroutines to reduce startup time. This change introduces a new \KoinCoroutinesEngine\ that manages background jobs for each lazy module, allowing true parallel initialization. Users can now use \lazyModules()\ to declare modules that are loaded lazily and in parallel, and can wait for all start jobs to complete using \waitAllStartJobs()\ or \awaitAllStartJobs()\. The \ModuleConfiguration\ class is also updated to support lazy modules and a custom \CoroutineDispatcher\.

projects/core/koin-core-coroutines/src/commonMain · high confidence

The Koin core library introduces new DSL markers (KoinApplicationDslMarker, KoinDslMarker, OptionDslMarker) and a new Module class that serves as the primary interface for defining and composing Koin modules. The Module class provides methods for singletons, factories, and scopes, and includes deprecated functions for binary compatibility with Koin 4.1.x.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module · medium confidence

The Koin core library now includes JVM-specific platform tooling. KoinPlatformTools.jvm.kt provides the actual implementation for generating unique IDs using Kotlin's experimental Uuid API, while KoinPlatformTools.kt supplies JVM-specific implementations for stack traces, class names, lazy modes, logging, and thread-safe collections. Additionally, ThreadLocal.kt defines the JVM-specific type alias for thread-local storage.

projects/core/koin-core/src/jvmMain/kotlin/org/koin/mp · high confidence

The Koin dependency injection library now includes platform-specific implementations for the global context and module extensions on Native and JS targets. On Native, the global context uses a lock-based mutable implementation to handle concurrency, while the JS version uses a simpler singleton pattern. Additionally, Native-specific extension functions are added to the Module class, allowing users to create factory and single bean definitions with explicit KClass types, enabling the Module API to be used without inlined KClass types on Native platforms.

projects/core/koin-core/src/jsMain/kotlin/org/koin/core, projects/core/koin-core/src/nativeMain/kotlin/org/koin/core · high confidence

The Koin core library has added support for the Wasm JS platform. This change introduces new platform-specific implementations for the global context and logging, enabling Koin to be used in Wasm JS environments. Specifically, the \GlobalContext\ and \PrintLogger\ classes have been implemented for the \wasmJsMain\ source set, allowing developers to initialize and manage Koin applications and view logs in Wasm JS applications.

projects/core/koin-core/src/wasmJsMain/kotlin/org/koin/core · high confidence

The Koin Ktor integration now supports bidirectional dependency injection between Koin and Ktor. Users can enable a bridge to resolve Ktor-declared dependencies via Koin's \inject()\ and resolve Koin-declared dependencies via Ktor's \by dependencies\ delegate. Additionally, the integration introduces a \requestScope\ module extension for defining dependencies in the Ktor request scope, and provides extension functions on \Application\, \ApplicationCall\, and \Route\ to access the Koin instance and resolve dependencies.

projects/ktor/koin-ktor/src/commonMain · high confidence

Koin introduces two new annotations to improve dependency management and verification. @InjectedParam can be used on constructor or function parameters to tag them as injected parameters for verification purposes. @Provided marks a dependency as already provided by Koin, such as those from DSL dynamic declarations or internal mechanisms. These annotations are now available in the koin-core-annotations module, allowing developers to explicitly mark and verify dependency injection scenarios.

projects/core/koin-core-annotations · high confidence

The Koin Android library introduces new DSL functions—activityScope, activityRetainedScope, and fragmentScope—allowing developers to declare dependencies scoped to the lifecycle of Android components. These functions enable more precise dependency management by tying object lifetimes to Activity, ActivityRetained, and Fragment instances, simplifying the creation of lifecycle-aware singletons and scoped dependencies in Android applications.

projects/android/koin-android/src/main/java/org/koin/androidx/scope/dsl · high confidence

Added KoinAndroidScope.kt, introducing KoinActivityScope and KoinFragmentScope Composable functions. These functions provide a convenient way to inject Koin dependencies within Android Activity and Fragment scopes in Jetpack Compose, automatically handling the scope context via CompositionLocalProvider.

projects/compose/koin-androidx-compose/src/main/java/org/koin/androidx/compose/scope · high confidence

The Koin DSL in \koin-core\ now provides \bind()\/\binds()\ to register secondary types for a definition, an \override()\ function to allow specific definitions to override existing ones even when global strict mode is active, and a \koinConfiguration\ helper to declare, extend, and reuse Koin configuration blocks via the new \KoinConfiguration\ class and \includes()\ extension. These changes alter how modules define type mappings and handle overrides, introducing new DSL entry points in the \org.koin.dsl\ package.

projects/core/koin-core/src/commonMain/kotlin/org/koin/dsl · high confidence

Added new test utilities for JUnit 4 and JUnit 5 to simplify Koin integration in tests. For JUnit 4, the \KoinTestRule\ automatically starts and stops the Koin context around each test, while \AutoCloseKoinTest\ and \ClosingKoinTest\ provide base classes that automatically close Koin after each test. For JUnit 5, the \KoinTestExtension\ provides equivalent lifecycle management via JUnit 5 extensions. Both versions also include \MockProviderRule\/\MockProviderExtension\ to facilitate mocking dependencies with Mockito, along with a \declareMock\ helper to replace real implementations with mocks during tests.

projects/core/koin-test-junit4 · high confidence

The Koin core library introduces a new 'Koin Fu' style of defining dependencies using constructor references, which enables compile-time resolution without reflection. This change adds several new extension functions to the module and scope DSLs: \new\ for instantiating types directly, and \singleOf\, \factoryOf\, and \scopedOf\ for creating definitions via constructor references. These functions support up to 22 constructor parameters and allow for optional configuration of definition options such as qualifiers, bindings, and lifecycle callbacks.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl · high confidence

A new Gradle plugin (org.koin.gradle.KoinPlugin) is introduced, which registers a 'checkModules' test task to validate Koin module configurations. Additionally, the Koin core library gains several new extension utilities: \KClassExt\ for retrieving full class names, \StringExt\ for stripping quotes, \InjectProperty\ for injecting mutable properties, \KoinApplicationExt\ for loading properties from files or environment variables on the JVM, a \PrintLogger\ for console output, a JVM-specific \Scope.get\ overload for Java interop, and a \KoinJavaComponent\ object providing static \inject\, \get\, and \getOrNull\ methods for Java code.

(repo-wide) · high confidence

A new file, KoinAnnotations.kt, introduces four new annotations to the Koin core library: @KoinInternalAPI, @KoinExperimentalAPI, @KoinDelicateAPI, and @KoinViewModelScopeApi. These annotations enforce stricter usage of internal, experimental, and delicate APIs, while the latter provides a specific scope marker for ViewModel integration.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/annotation · high confidence

Added new annotation classes to the Koin annotations library, including \@ActivityScope\, \@ActivityRetainedScope\, and \@FragmentScope\ for Android-specific dependency injection scopes, as well as \@ViewModelScope\ for ViewModel-scoped dependencies. The update also introduces \@KoinWorker\ for Android Worker definitions and \@Monitor\ for performance tracing via the Kotzilla Platform. These annotations enable developers to declaratively define singletons, factories, and scoped dependencies with automatic binding and lifecycle management.

projects/core/koin-annotations · high confidence

The Koin library introduces a new way to manage the global Koin context. A new \KoinContext\ interface defines the contract for starting, stopping, and managing modules in the default context. Additionally, a \DefaultContextExt.kt\ file provides extension functions like \startKoin\ and \loadKoinModules\ that delegate to this new context, allowing users to initialize and manage their Koin application more cleanly.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/context · high confidence

The Koin core library introduces a suite of new exception classes to handle specific error conditions more precisely. These include \ClosedScopeException\ for operations on closed scopes, \DefinitionOverrideException\ for conflicting definitions, \InstanceCreationException\ for failures during instance creation, \KoinApplicationAlreadyStartedException\ to prevent duplicate initialization, \MissingPropertyException\ and \MissingScopeValueException\ for unresolved configuration, \NoDefinitionFoundException\ and \NoParameterFoundException\ for missing definitions or parameters, \NoPropertyFileFoundException\ for missing property files, \NoScopeDefFoundException\ for missing scope definitions, and \ScopeAlreadyCreatedException\ and \ScopeNotCreatedException\ for invalid scope state transitions. These changes improve error handling and debugging for Koin users.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/error · high confidence

A new extension system has been introduced to allow users to add custom features to Koin. This includes a new \KoinExtension\ interface with \onRegister\ and \onClose\ lifecycle methods, and an \ExtensionManager\ class that handles the registration and retrieval of these extensions within the Koin container.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/extension · high confidence

A new \koin-dagger-bridge\ module has been introduced to enable Koin to access Dagger/Hilt components. This allows developers to retrieve Dagger-defined dependencies within Koin scopes using the \dagger()\ extension functions, facilitating interoperability between the two dependency injection frameworks.

projects/android/koin-dagger-bridge · medium confidence

The Koin library introduces two new interfaces, KoinComponent and KoinScopeComponent, to simplify dependency injection. KoinComponent provides a convenient get() method to retrieve instances from the Koin container, while KoinScopeComponent extends this with scope management capabilities, allowing objects to create, retrieve, and manage their own scopes. This enables developers to inject dependencies and manage scoped instances more easily within their classes.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/component · high confidence

A new \org.koin.mp\ package introduces platform-specific abstractions for Kotlin Multiplatform, including \KoinPlatform\ for simplified start/stop and instance retrieval, \KoinPlatformTools\ for stack traces, logging, and ID generation, and \ThreadLocal\ for thread-safe storage. This provides a consistent API across platforms while allowing platform-specific implementations.

projects/core/koin-core/src/commonMain/kotlin/org/koin/mp · high confidence

Added new extension functions to retrieve ViewModels from Koin for Android ComponentActivity, Fragment, and Fragment-based components. These include \viewModel\ and \getViewModel\ for Activities and Fragments, as well as \viewModelForClass\ for explicit class-based resolution, enabling developers to inject ViewModels with qualifiers, creation extras, and parameters directly from Android UI components.

projects/android/koin-android/src/main/java/org/koin/androidx/viewmodel/ext · high confidence

The Koin library introduces a new public API for managing dependency injection with Kotlin Coroutines. This includes a \KoinCoroutinesEngine\ to handle start jobs and wait for Koin initialization, along with extension functions like \onKoinStarted\, \waitAllStartJobs\, and \awaitAllStartJobs\ to synchronize coroutine-based workflows with the Koin lifecycle. Additionally, a \LazyModule\ type and \lazyModules\ configuration options are exposed, allowing modules to be loaded lazily and in parallel during startup, improving initialization performance.

projects/core/koin-core-coroutines · high confidence

A new Composable function, koinActivityViewModel, has been added to the Android-specific Koin Compose ViewModel module. This function resolves a ViewModel instance scoped to the current Activity's lifecycle by leveraging the Activity as the ViewModelStoreOwner. This provides a convenient way to inject ViewModels that are tied to the Activity's lifecycle, distinct from the existing koinViewModel which may use different scoping.

projects/compose/koin-compose-viewmodel/src/androidMain · high confidence

The \koin-compose-viewmodel-navigation\ module now exposes a new public API for managing Koin scopes tied to Jetpack Compose Navigation back stack entries. A \navigationScope\ DSL function is added to \Module\ to define dependencies scoped to individual navigation destinations, while \KoinNavigationScope\ and \rememberKoinNavigationScope\ provide the corresponding Composable functions to create and manage these scopes. Additionally, \NavBackStackEntry.sharedKoinViewModel\ is introduced to allow reusing ViewModel instances across navigation graph boundaries, and the legacy \koinNavViewModel\ function is marked as deprecated in favor of the standard \koinViewModel\.

projects/compose/koin-compose-viewmodel-navigation · high confidence

The Koin Compose integration has been reworked to use a new \ComposeContextWrapper\ for managing the Koin context and scope lifecycles within Compose. This introduces new composable entry points including \KoinApplication\ (with a \KoinConfiguration\ parameter), \KoinScope\, \UnboundKoinScope\, and \rememberKoinModules\ for automatic module loading and unloading. The \koinInject\ API now supports \ParametersHolder\ directly to avoid unwrapping parameters on every recomposition. Android-specific setup is handled via \KoinApplication\ which automatically configures the Android context and logger. The previous \LocalKoinScope\ and \LocalKoinApplication\ are deprecated in favor of \LocalKoinScopeContext\ and \getKoin()\.

projects/compose/koin-compose · high confidence

The public API signature for the Koin Gradle plugin is now explicitly defined, exposing the plugin class and its apply method to ensure stable binary compatibility for consumers relying on the plugin's public interface.

projects/plugins/koin-gradle-plugin/api · high confidence

The public API surface for the Koin AndroidX Compose Navigation integration has been updated to include the \NavViewModelInternalsKt\ class, specifically exposing the \defaultNavExtras\ function. This function, which accepts a \ViewModelStoreOwner\, a \Composer\, and an integer, is now part of the public API, allowing developers to access default navigation extras in a Compose-based navigation setup.

projects/compose/koin-androidx-compose-navigation · high confidence

The public API for the Koin AndroidX Compose integration is now explicitly defined, exposing the \KoinAndroidContext\, \KoinActivityScope\, and \KoinFragmentScope\ functions to consumers. This establishes the stable interface for managing Koin scopes within Compose UI components.

projects/compose/koin-androidx-compose · high confidence

The internal registry implementation has been refactored into four distinct, specialized classes: InstanceRegistry for managing bean instances, ScopeRegistry for handling scope lifecycle and creation, PropertyRegistry for storing application properties, and OptionRegistry for feature flags. This change reorganizes how Koin stores and resolves dependencies, scopes, and configuration, which may affect internal behavior and stability.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/registry · high confidence

Added a new file containing performance benchmark results for the Android examples app. The file includes execution metrics for various Android devices (OnePlus Nord, Nokia 7p, Honor 5x, LG G4) comparing performance between versions 2.0.1 and 2.1.0-alpha-8.

examples/android-perfs · medium confidence

The examples directory now includes a README specifying Java 17, along with shell scripts (clean.sh, test.sh) and Gradle wrapper scripts (gradlew, gradlew.bat) to streamline building and testing the example projects.

examples · high confidence

The koin-compose-viewmodel and koin-core-viewmodel modules now ship with consumer-rules.pro files that automatically suppress R8 warnings about Koin internals. This ensures smoother minification and obfuscation for apps using these libraries, with guidance pointing to the R8/ProGuard documentation for additional configuration.

projects/compose/koin-compose-viewmodel, projects/core/koin-core-viewmodel · high confidence

The Android modules now ship with explicit API dump files (koin-android.api, koin-android-compat.api, etc.) that define the public surface for components like AndroidScopeComponent, KoinInitializer, and KoinWorkerFactory. Additionally, consumer R8/ProGuard rules are included in the AARs for koin-android, koin-androidx-startup, and koin-androidx-workmanager to suppress internal warnings and ensure class preservation.

projects/android · high confidence

The Koin coroutine integration now uses Dispatchers.Default as the default coroutine dispatcher, rather than the previous default. This change affects how Koin-managed coroutines are scheduled on the JVM platform, potentially impacting performance and resource usage for background tasks.

projects/core/koin-core-coroutines/src/jvmMain/kotlin/org/koin/mp · high confidence

The \org.koin.androidx.viewmodel.dsl\ package, including \ModuleExt\, \ScopeSetExt\, \ScopeViewModelOf\, and \ViewModelOf\, is now marked as deprecated. Developers should migrate their imports from \org.koin.androidx.viewmodel.dsl\ to \org.koin.core.module.dsl\ to use the unified ViewModel DSL provided by the \koin-viewmodel\ module.

projects/android/koin-android/src/main/java/org/koin/androidx/viewmodel/dsl · high confidence

The ViewModel DSL functions in the \org.koin.compose.viewmodel.dsl\ package (including \Module.viewModel\, \ScopeDSL.viewModel\, \Module.viewModelOf\, and \ScopeDSL.viewModelOf\) are now deprecated. Developers should migrate their code to use the unified ViewModel DSL available in \org.koin.core.module.dsl.\*\ to share definitions across Android and Compose.

projects/compose/koin-compose-viewmodel/src/commonMain/kotlin/org/koin/compose/viewmodel/dsl · high confidence

The \koinNavViewModel\ composable function is now deprecated and will be removed in a future release. Users should migrate to \koinViewModel\, which provides the same functionality without the navigation-specific extras. The deprecated function now includes a \replaceWith\ annotation to guide automatic refactoring, and internal helper functions like \defaultNavExtras\ are also marked as deprecated.

projects/compose/koin-androidx-compose-navigation/src/main/java · high confidence

The public API surface for the koin-compose-viewmodel module has been cleared, resulting in empty API signature files for Android, JVM, and the general module. This indicates that the module currently exposes no public API elements.

projects/compose/koin-compose-viewmodel/api · medium confidence

Users can now activate ViewModelScope creation at the factory level by enabling the new KoinOption. This change introduces a mechanism to create a dedicated scope for each ViewModel at creation time, allowing ViewModels to automatically close their associated scope when they are no longer needed, improving resource management in Android applications.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/option · medium confidence

The Koin library now provides a concrete implementation of the global Koin context for the JVM target. This change introduces the GlobalContext object, which manages the lifecycle of the global Koin application instance. Users can now start, load, and unload Koin modules via this global context, ensuring that the Koin application is initialized only once and providing a centralized way to access the current Koin instance.

projects/core/koin-core/src/jvmMain/kotlin/org/koin/core/context · medium confidence

The Gradle wrapper has been upgraded from version 3.3 to 8.11.1. This change updates the underlying build tool used to compile and run the example application, which may affect build performance and compatibility with newer Java or Android Gradle Plugin versions.

examples/gradle · high confidence

The Gradle build scripts for publishing artifacts have been restructured into dedicated configuration files (publish-android, publish-java, publish-pom, publish, and signing). This change ensures that source and Javadoc JARs are correctly included in Maven publications for Android, Java, and POM modules. Additionally, the signing process is now explicitly configured to depend on the signing task for all relevant Maven and Sonatype/Nmcp repositories, ensuring that all published artifacts are properly signed during release builds.

projects/gradle · medium confidence

The Koin ViewModel integration now automatically creates and manages a dedicated scope for each ViewModel, linking it to the parent scope to ensure proper dependency resolution. Additionally, the framework now provides a clear, actionable error message when a ViewModel's CreationExtras lacks a SavedStateRegistryOwner, preventing confusing low-level exceptions.

projects/core/koin-core-viewmodel/src/commonMain/kotlin/org/koin/viewmodel/factory · medium confidence

The Koin core library now handles environment and system properties more robustly. Previously, loading properties from the environment or system could trigger a ClassCastException if non-String values were encountered. The new implementation in PropertyRegistryExt.kt safely filters out non-String keys and avoids hard-casting values to String, ensuring that only valid String-keyed entries are saved. This prevents application crashes when environment properties contain unexpected types.

projects/core/koin-core/src/jvmMain/kotlin/org/koin/core/registry · medium confidence

The public API for the Ktor integration modules (koin-ktor and koin-ktor3) and the SLF4J logging module (koin-logger-slf4j) has been formalized with new API signature files. This exposes the Koin integration with Ktor's application lifecycle, dependency injection, and request scopes, as well as the SLF4J logger implementation, making these libraries' public interfaces explicit and stable for consumers.

projects/ktor · high confidence

The Koin core library now provides platform-specific implementations for the KoinPlatformTools on JavaScript and Native targets. On JS, it uses Kotlin's experimental Uuid API for ID generation and Stately's ConcurrentMutableMap/Set for safe collections. On Native, it similarly uses Stately for safe collections and locks, but employs a different lazy mode (PUBLICATION vs NONE) and uses globalContextByMemoryModel for context management. This ensures thread-safe operations and consistent behavior across these platforms.

projects/core/koin-core/src/jsMain/kotlin/org/koin/mp, projects/core/koin-core/src/nativeMain/kotlin/org/koin/mp · medium confidence

The qualifier system in the core library has been reworked to use dedicated implementation classes for string and type-based qualifiers. The \Qualifier\ interface and \QualifierValue\ typealias are introduced, along with \StringQualifier\ and \TypeQualifier\ classes that replace previous internal structures. This change affects how components are identified and resolved within scopes, ensuring that string-based qualifiers use lowercase normalization for enums and type-based qualifiers use full class names for identification.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/qualifier · medium confidence

The Koin and KoinApplication classes have been refactored to improve internal structure and performance. The Koin class now exposes an addResolutionExtension method to support external dependency injection systems, and the KoinApplication class introduces a strictOverride mode to enforce explicit overrides. These changes modify how the core container and application setup behave, particularly regarding module loading and override policies.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core · medium confidence

The core bean definition logic has been reorganized into the \org.koin.core.definition\ package, introducing new \BeanDefinition\, \KoinDefinition\, and \Callbacks\ classes. This refactoring consolidates the internal representation of bean definitions, including support for secondary types and lifecycle callbacks, while maintaining binary compatibility with previous versions through a deprecated constructor.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/definition · medium confidence

The resolution logic in the core module has been refactored to support external dependency injection integrations and improve scope resolution accuracy. A new \ResolutionExtension\ interface and \InstanceResolver\ abstraction allow external systems (like Ktor) to hook into the resolution process. The \CoreResolver\ and \CoreResolverV2\ classes implement this abstraction, introducing a more robust chain of resolution steps—prioritizing injected parameters, registry lookups, stacked parameters, and linked scopes. This change fixes several scope resolution issues, including handling of child scopes, stacked parameters, and root factory scoped dependencies, ensuring that linked scopes and archetype lookups function correctly across different scope hierarchies.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/resolution · high confidence

The internal mechanism for managing bean instances has been refactored into a new \org.koin.core.instance\ package. This introduces an abstract \InstanceFactory\ base class and specific implementations for different scopes: \SingleInstanceFactory\ for singletons, \ScopedInstanceFactory\ for scoped dependencies, and \FactoryInstanceFactory\ for transient objects. This change restructures how Koin creates, caches, and cleans up instances, which may affect internal behavior but provides a more robust and thread-safe foundation for dependency resolution.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/instance · high confidence

The \EmptyModule\ and \Module\ classes in the \org.koin.module\ package have been removed. These previously provided a base class for defining beans within an actual context, along with a convenience method \declareContext\. Their removal indicates a shift in how Koin handles module definitions, likely as part of the broader DSL and scope rework mentioned in the commit history.

src/main/kotlin/org/koin/module · medium confidence

The legacy core classes for dependency injection have been removed: BeanRegistry, Context, InstanceFactory, Koin, and PropertyResolver, along with their associated bean and error types. This eliminates the previous API for defining and resolving singletons, factories, and stack-scoped beans, as well as property resolution, indicating a significant restructuring of the framework's core architecture.

src/main/kotlin/org/koin · high confidence

The Koin core library introduces a new \ParametersHolder\ class to manage dependency injection parameters. This change stabilizes parameter injection by supporting both indexed and set-based parameter retrieval, ensuring that parameters are injected consistently and predictably. Users can now use \parametersOf\, \parameterArrayOf\, or \parameterSetOf\ to define parameters, with the latter two allowing for more explicit control over parameter ordering and type matching. This addresses previous instability in parameter injection, making the behavior more reliable for complex injection scenarios.

projects/core/koin-core/src/commonMain/kotlin/org/koin/core/parameter · medium confidence

The public API for the Koin core library has been updated, introducing new methods and parameters for scope creation and management. Specifically, the \Koin\ class now exposes \createScope\ and \getOrCreateScope\ methods that accept additional parameters for qualifiers and type qualifiers, while \KoinApplication\ gains an \options\ method for configuration. These changes expand the capabilities for managing scopes and configuring the Koin instance.

projects/core/koin-core · medium confidence

Add Koin test API dump for module verification; Add module verification tests for dependency injection; Added Android-specific unit tests for Koin integration; Added Android-specific verification tests; Added AndroidX sample tests for module verification and activity launching; Added JVM test suite for Koin core; Added JVM tests for Koin coroutines integration; Added KoinTest interface and MockParameter helper for testing; Added performance test runner for Koin benchmarks; Added test coverage for Koin's lazy module operator; Added test suite for Koin module declaration and qualifier injection; Added tests for Koin and Ktor dependency injection bridge; Added tests for Ktor integration features; Added tests for ViewModel resolution edge cases; Added tests for ViewModel scope archetype behavior; Added unit tests for Android ViewModel resolution; Added unit tests for Android scope archetypes; Added unit tests for the coffee maker example; Deprecate checkModules() API in favor of verify(); Expanded test coverage for Koin core resolution and scoping; New mock declaration utilities in koin-test; Removed obsolete Koin test suite.

The project dependencies have been updated to Koin 4.2.1 and JetBrains Compose 1.10.0. This includes updates to the Koin core, Android, and Compose modules, as well as the Ktor integration. The version catalog in \examples/gradle/versions.gradle\ now specifies \koin\_version\ 4.2.1, \jb\_compose\_version\ 1.10.0, and \ktor\_version\ 3.3.1.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 46 → 67 (+21.3)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 96 → 98 (+1.6)
• Architecture 96 → 99 (+3.9)
• Maturity 58 → 65 (+7.4)
• Readiness 37 → 64 (+27.8)
• Security 35 → 62 (+26.7)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (21 lines × 2) (projects/core/koin-core/src/commonMain/kotlin/org/koin/plugin/module/dsl/CreateDSL.kt)
• Duplicated block (41 lines × 3) (projects/android/koin-android/src/main/java/org/koin/androidx/fragment/dsl/ScopeFragmentOf.kt)
• Duplicated block (41 lines × 3) (projects/android/koin-androidx-workmanager/src/main/java/org/koin/androidx/workmanager/dsl/ScopeWorkerOf.kt)
• Duplicated block (41 lines × 3) (projects/android/koin-androidx-workmanager/src/main/java/org/koin/androidx/workmanager/dsl/WorkerOf.kt)
• Duplicated block (41 lines × 3) (projects/core/koin-core-viewmodel/src/commonMain/kotlin/org/koin/core/module/dsl/ScopeViewModelOf.kt)
• Duplicated block (41 lines × 3) (projects/core/koin-core-viewmodel/src/commonMain/kotlin/org/koin/core/module/dsl/ViewModelOf.kt)
• Duplicated block (41 lines × 3) (projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/FactoryOf.kt)
• Duplicated block (41 lines × 3) (projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/ScopedFactoryOf.kt)
• Duplicated block (41 lines × 3) (projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/ScopedOf.kt)
• Duplicated block (41 lines × 3) (projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/SingleOf.kt)
• Duplicated block (42 lines × 3) (projects/android/koin-android/src/main/java/org/koin/androidx/fragment/dsl/FragmentOf.kt)
• Duplicated block (46 lines × 3) (projects/android/koin-android/src/main/java/org/koin/androidx/viewmodel/dsl/ScopeViewModelOf.kt)
• Duplicated block (46 lines × 3) (projects/android/koin-android/src/main/java/org/koin/androidx/viewmodel/dsl/ViewModelOf.kt)
• Duplicated block (46 lines × 3) (projects/compose/koin-compose-viewmodel/src/commonMain/kotlin/org/koin/compose/viewmodel/dsl/ScopeViewModelOf.kt)
• Duplicated block (46 lines × 3) (projects/compose/koin-compose-viewmodel/src/commonMain/kotlin/org/koin/compose/viewmodel/dsl/ViewModelOf.kt)
• Duplicated block (8 lines × 8) (projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/New.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 17 more

• Change coupling: FactoryOf.kt ↔ SingleOf.kt (projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/FactoryOf.kt)
• CoreResolverV2.resolveFromLinkedScopes (cognitive 17) (projects/core/koin-core/src/commonMain/kotlin/org/koin/core/resolution/CoreResolverV2.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: written for insiders (docs/intro/what-is-dependency-injection.md)
• Documentation: written for insiders (docs/quickstart/kotlin.md)
• Duplicated block (177 lines × 2) (projects/android/koin-android/src/main/java/org/koin/androidx/fragment/dsl/FragmentOf.kt)
• Duplicated block (177 lines × 2) (projects/android/koin-androidx-workmanager/src/main/java/org/koin/androidx/workmanager/dsl/ScopeWorkerOf.kt)
• Duplicated block (177 lines × 2) (projects/core/koin-core/src/commonMain/kotlin/org/koin/core/module/dsl/FactoryOf.kt)
• Duplicated block (177 lines × 6) (projects/android/koin-android/src/main/java/org/koin/androidx/viewmodel/dsl/ScopeViewModelOf.kt)
• Duplicated block (35 lines × 3) (projects/ktor/koin-ktor/src/commonMain/kotlin/org/koin/ktor/ext/ApplicationCallExt.kt)
• Duplicated block (43 lines × 2) (projects/core/koin-core/src/jsMain/kotlin/org/koin/core/context/GlobalContext.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No dependency advisory monitoring
• Orphaned files with no living knowledge
• PR-triggered workflow without a permissions block
• …and 38 more

• Containers 0 added · 0 removed · contexts 8 added · 0 removed · edges 9 added · 0 removed

• android-perfs
• androidx-samples
• hello-ktor
• jvm-perfs
• koin-android
• koin-core
• koin-ktor
• sample-android-compose

• android-perfs → jvm-perfs (coupling)
• androidx-samples → koin-android
• androidx-samples → koin-core
• hello-ktor → koin-core
• jvm-perfs → koin-core
• koin-android → koin-core (coupling)
• koin-ktor → koin-core (coupling)
• sample-android-compose → koin-android
• sample-android-compose → koin-core (coupling)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

InsertKoinIO/koin was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.