Browse Kotlin Multiplatform libraries

Facilitates asynchronous Remote Procedure Call (RPC) services with simplified integrations, supporting flow-based data streaming. Offers transport-agnostic design, seamless integration with existing solutions, and customizable serialization protocols.

Implements Elm-inspired Model-View-Update architecture for creating composable, testable programs. Utilizes a common codebase with a `render` function for platform-specific frontends.

Generates mutable models from immutable definitions, simplifying state updates and reducing boilerplate code. Inspired by Redux and Immer, offers atomic field updates and reactive immutable value updates using `StateFlow`.

Automatically generates wrappers for `suspend` functions and `Flow` for easy access from Swift code. Provides seamless integration with coroutine-based functions, offering features like custom scope providers and interface generation.

Lightweight caching library supports both in-memory and persistent caches with various eviction strategies (LRU, FIFO, MRU, FILO), offering coroutine-friendly operations and a simple, modern API.

Framework for writing composable parsers based on coroutines. Enables defining grammars and tokens in a declarative manner. Features stack-neutral processing, extensibility, and pure non-generated code for easy debugging.

Facilitates network operations by generating API classes and entities from OpenAPI specifications, supports token-based authentication, error handling, and token refreshment, enhancing networking capabilities.

Enables creation of restartable, pausable, or one-shot state flow instances, enhancing control over data streams and state management in complex scenarios.

Light ORM enabling type-safe SQL with idiomatic syntax. Supports JDBC, R2DBC, Vertx sqlclient, and various databases including PostgreSQL, MySQL, and SQLite. No annotations or code generation required.

Enforces structured concurrency for coroutines via compiler checks, static analyzers, IDE inspections, lint rules and annotations — compile-time errors, quick fixes, tool window, zero runtime overhead.

Railway-oriented library simplifies handling success and failure with a normalized `Result` model. Integrates seamlessly with Retrofit, offering extensions for chaining operations, error handling, and retry policies, enhancing functional programming practices.

Powerful, flexible pagination toolkit with bidirectional navigation, arbitrary jumps, bookmarks, caching, element-level CRUD, capacity/incomplete-page handling, reactive snapshot flows, parallel loading and state serialization.

Coroutine-based Redis client enables efficient interaction with Redis using raw sockets and connection pooling, supporting comprehensive Redis commands, pipelining, transactions, and pub/sub functionalities.

Generates blocking bridges for calling suspend functions from Java, simplifying integration. Automatically creates non-suspend bridge functions, ensuring minimal effort and high stability for production use.

Production-ready permission manager eliminating lifecycle boilerplate and fragments; automatic rationale/settings dialogs, service checks for GPS/Bluetooth, dead-click and gallery permission edge-case fixes, thread-safe API.

Library enables cross-platform file I/O, including text, binary, and zip/archive files. Features coroutine support, charset encoding/decoding, bitwise operations, byte buffers with endian support, and customizable zip file handling.

Manages data consistency across microservices using the saga design pattern. Facilitates distributed transactions with a convenient DSL, enabling automatic rollbacks and compensating actions for composed operations.

Library aids in managing state using unidirectional data flow principles, offering tools to mutate state over time via `StateMutator` implementations. Supports MVVM and MVI patterns.

Lightweight observability for coroutines offering real‑time lifecycle tracing, P50/P90/P99 metrics, failure rates, flexible sampling strategies, pluggable exporters, and live trace visualization.

Client library enabling real-time communication with ASP.NET Core servers. Supports server push, client-server messaging, coroutines for async tasks, customizable serialization, automatic reconnect, and streaming.

Enables building concurrent systems using the actor model, leveraging coroutines for asynchronous message passing. Supports clustering for scalability and fault tolerance, under active development.

Integrate Algolia within projects, offering seamless JSON parsing, asynchronous operations, and thread-safe clients. Features include coroutine support, type safety, and comprehensive documentation links embedded in source files.

Enables automatic exception handling and user-friendly error presentation with customizable strategies like alerts, toasts, and snackbars. Supports mapping exceptions to error objects for consistent error display.

Asynchronous coroutine-based client for Chrome DevTools Protocol; supports browser automation, debugging, and interaction with Chrome targets through type-safe domain commands and event handling.

Implements a thread-safe event bus using channels for multi-key, multi-producer, single-consumer communication. Supports unbounded and conflated channels, ensuring all events are consumed. Ideal for UI applications.

Facilitates separation of business logic from view logic through controllers, enabling UI-independent state management and unit testing. Offers comprehensive examples and detailed documentation.

Lightweight library for mobile app architecture, leveraging coroutines, SharedFlow, and StateFlow. Manages state immutability, actions, side effects, and events, while integrating seamlessly with Android's ViewModel class.

Facilitates reactive state management and ViewModels with minimal boilerplate. Features include automatic recomputation, on-demand resource allocation, error handling, coroutine-based testing, lifecycle management, and state restoration.

Simple, predictable state management library inspired by Flux, Elm, and Redux. Built on coroutines and structured concurrency. Highly extensible and adaptable for various architectures without platform-specific dependencies.

Facilitates parallel operations like map and reduce on collections using coroutines, enhancing performance with chunked operations for efficient multithreading and data locality benefits.