Browse Kotlin Multiplatform libraries

Facilitates domain-driven design with features like Command and Query Responsibility Segregation, Event Sourcing, and test-driven development. Generates application layer code, supports coroutines, and offers compile-time serialization.

Multiplatform framework enables shared code development using The Elm Architecture pattern, offering clear separation of logic and presentation for modular, testable code with error resilience.

Framework enhances application development using Model-View-Intent pattern with core components, type-safe state management, unidirectional data flow, coroutine-based asynchronicity, and extensibility.

Offers common architecture components for building scalable and maintainable applications, enhancing modularity and reusability in software development.

Simplifies project structuring using Domain-Driven Design principles, offering interfaces, classes, and an event bus for efficient component decoupling and clearer code organization.

Enables efficient state management with an MVI framework, featuring state rendering, action dispatching, event handling, and middleware integration for customizable application architecture, including support for Compose.

Delegate-based ViewModel composition enabling smaller, testable MVVM modules; unidirectional state flow, pure delegates, explicit state/effect handling, fast builds and Compose-friendly UI binding.

Powerful MVLI library enhances state management and navigation using unidirectional data flow, type-safe navigation, Jetpack Compose integration, coroutine support, and modular design.

Accelerates cross-platform development with a modern, scalable template featuring a shared business logic, unified UI code, modular architecture, robust CI/CD workflows, and code quality tools.

Simplifies building Model-View-Intent architecture by managing ViewModel states, events, and effects. Supports state restoration, event handling, and integrates seamlessly with Compose UI components.

Framework architecture simplifies Android project creation using an MVI-based approach with state management, emphasizing clean architecture. Integration through Jitpack supports compose, core, and common modules.

Facilitates template-based project generation, streamlining setup and configuration processes for new projects with customizable templates and predefined structures.

Pure domain layer enforcing Clean Architecture with typed contracts, DomainResult error handling, composable validators and policies, deterministic testing via injected clock and id providers, no framework dependencies.

Secure, modular SDK for remote data access: pluggable HTTP/WebSocket transports, centralized execution pipeline, consistent error classification, credential/session management, certificate pinning, and guides.

Lightweight, type-safe state-management architecture with expressive DSL, lifecycle-aware state retention, granular state observation, effect/signal handling, and cancellable asynchronous jobs for reactive UI development.

Event and result observation with DataResult, LiveData/Flow wrappers, chaining/mapping/merge helpers and a Compose-first DSL for declarative loading, data, error and collection handling.

UI-agnostic form validation toolkit standardizing immutable, testable input states; supports custom and dynamic validations, aggregated form validity, and submission lifecycle handling.

Library enhances mobile development with Model-View-Intent (MVI) pattern support, offering core classes and optional extensions for Android ViewModel and multiplatform MVVM integration.

Concise reactive state management library enables structured handling of application states, actions, and effects with a minimalistic API, promoting scalability, predictability, and testability.

Opinionated architecture library enables concurrent, reactive state management, platform-independent routing, and file handling. Includes typed result type for railway-oriented programming and helpful extensions.

Showcases clean architecture principles in an Android app, offering guidelines and best practices with layered project structure and integration with Open Weather API for demonstration.

Enhances state management in projects, offering a store class with builders for architecture patterns, intent actions, reducers, side effects, and state collection in composable methods.

Implements the Model-View-Intent pattern for managing complex UI states with predictability, testability, and maintainability. Offers explicit state modeling, unidirectional data flow, and handles asynchronous operations effectively.

ViewModel-driven navigation architecture enabling sealed scenes, NavigationState actions (push/pop/present), SceneRepository for passing data, plus declarative UI integration and modal-stack manager.

Shared architecture primitives for clean, layered apps: lifecycle-aware BaseViewModel exposing StateFlow with native-coroutines observation, ViewModelState marker, and sync/suspend/flow UseCase variants.

Lightweight coroutine-based unidirectional data-flow architecture for predictable state management, mapping events→actions→results→state, with interactor pipelines, side-effect handling, lifecycle-scope integration and UI screen binding.

State-of-the-art starter pack organizing code with Clean Architecture and DDD: layered Domain/Data/Presentation, use-case invoke patterns, self-validating models, Koin DI, optimized CI/CD.