Browse Kotlin Multiplatform libraries

Pragmatic lightweight dependency injection framework using a DSL and light container. Offers packages for core, coroutines, testing, Android, Ktor, annotations, and Jetpack Compose integration. Includes tutorials and community support.

Straightforward dependency retrieval container offering lazy instantiation, binding, and debugging capabilities. Integrates with Android, Compose, and Ktor. Provides a simple, readable declarative DSL.

Breaks down code into tree-structured, lifecycle-aware business logic components with routing and pluggable UI support. Offers clear UI/non-UI separation, dependency injection, state preservation, and custom navigation models.

Compile-time dependency injection library enabling seamless construction of type instances through annotations like `@Component`, `@Provides`, and `@Inject`. Supports component arguments, type alias differentiation, function injection, scopes, component inheritance, multi-bindings, assisted injection, lazy initialization, and default arguments.

Lightweight Redux/MVI-like library offering a simple, type-safe, coroutine-based API. Features include lifecycle-safe flow collection, ViewModel support, unit testing, espresso idling resources, and compatibility with RxJava and LiveData. Ideal for state management and side-effect handling.

Metro is a compile-time dependency injection framework that draws heavy inspiration from Dagger, Anvil, and Kotlin-Inject. It seeks to unify their best features under one, cohesive solution while adding a few new features and implemented as a compiler plugin.

Offers Model-View-ViewModel architecture components for UI applications, featuring lifecycle-aware ViewModel, LiveData, EventsDispatcher, and integration with various UI tools like DataBinding, ViewBinding, and SwiftUI.

Framework enabling MVI pattern implementation with features like logging, time travel, and lifecycle-aware connections. Flexible architecture supports various reactive libraries or none, facilitating incremental adoption and experimentation.

Extensive architectural framework for developing reactive applications with features like automatic state preservation, remote debugging, error recovery, and a powerful plugin system for reusing business logic.

Provides a DSL and coroutine-based framework for building asynchronous state machines, simplifying state transitions and handling actions with concise syntax and reactive state management.

Enables use of AndroidX ViewModels in SwiftUI, ensuring state changes propagate correctly. Provides wrappers for seamless integration with SwiftUI and supports creating and managing ViewModels across different platforms.

Extends AndroidX Paging with additional targets and iOS UI components, enabling shared pagination logic across various platforms. Includes common, runtime, compose, and testing modules for seamless integration.

Simplifies Bluetooth Low Energy usage with coroutine-based asynchronous APIs: scanning, connecting (autoConnect), GATT reads/writes, MTU/PHY management, notifications, and mock environments for testing.

Enables compile-time dependency injection with automatic merging of component interfaces, simplifying the creation and management of object graphs through annotations like `@ContributesTo`, `@ContributesBinding`, and `@MergeComponent`.

Compose-multiplatform navigation library leveraging Decompose to manage screen configurations with a `Router`, supporting retention of view models across configuration changes and multiple platforms.

Facilitates pagination in codebases, enabling common pagination logic for both Android and iOS. Integrates with platform-specific libraries, exposing paginated data as flows for easy consumption.

Facilitates implementation of the Presentation Layer, focusing on state management, lifecycle awareness, navigation, and state persistence. Supports hierarchical view composition and messaging between components.

Intuitive, customizable pagination solution built on lazy lists, automatically managing pagination states during scrolling. Includes error handling, retry, and refresh functionalities, ideal for seamless integration into UI or ViewModel.

Shared MVVM library for UI applications with lifecycle-aware components, state restoration, and interoperability with Swift/Objective-C and SwiftUI. Supports multiple platforms, including Compose Multiplatform.

Simple, powerful, and lightweight dependency injector allowing usage without extra files. Supports various scopes, environments, runtime arguments, and interface injections. Ideal for Android, iOS, JVM, and JS development.

Simplifies dependency injection with compile-time validation and faster compilation by generating code for dependency resolution. Features include constructor-based injection, singleton management, and module scoping without runtime file generation.

Next-gen dependency injection library offering a streamlined approach to providing and injecting dependencies, supporting multi-injection, scoping, modules, components, function injection, and type distinguishing strategies.

Injection library for Compose, wrapping Koin. Configures dependency injection using `@Composable` functions, supports scoped dependencies, ViewModel integration, and Compose navigation enhancements.

Library for compile-time dependency injection, emulating Dagger features. Utilizes Kotlin Symbol Processing, supporting constructor injection, component provision, and scope annotations. Lacks field injection and other advanced Dagger functionalities.

Facilitates application development using the MVI architecture, unidirectional data flow, and asynchronous code integration. Features include state management, common use cases, and easy testing.

Comprehensive SDK enables development of scalable, maintainable applications by integrating MVVM architecture, navigation, CLI tools, and IoC container. Features include compile-time dependency injection and resource generation.

Lightweight runtime dependency injection container enables easy registration and retrieval of dependencies with features like auto-wiring, singletons, bindings, qualifiers, modules, and scopes management.

Multi-platform, compile-time dependency injection framework designed for simplicity and ease of use. Features include dependency graphs, scopes, type inference, modules, and flexible overriding options. Avoids reflection-based solutions, promoting efficient and scalable dependency management.

Simplifies dependency injection by automatically merging Dagger modules and component interfaces, reducing boilerplate code and improving build efficiency. Supports custom code extensions.

Core infrastructure for a file-transfer system: unified network APIs, Realm-backed database, shared utilities, and an injection model abstracting API/database logic into simple manager calls.