Browse Kotlin Multiplatform libraries

Enables asynchronous programming with lightweight coroutines, offering structured concurrency, cancellation, and integration with various reactive streams and UI frameworks. Includes testing and debugging utilities.

Framework for testing concurrent algorithms on the JVM. Enables declarative test specification, automatically generates random scenarios, and verifies correctness properties using stress-testing or model checking.

Implements a single-writer concurrent hashmap allowing lock-free, wait-free reads. Supports coroutines, ensuring non-blocking operations, and uses left-right concurrency for efficient data management.

Portable utilities: sprintf-style formatting with advanced flags, base64 (including URL-safe), fast Boyer–Moore byte search, ByteArray int ops, cached expressions, reentrant coroutine mutex, coroutine-based async logging.

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.

Provides a comprehensive set of utilities for collections, coroutines, date-time, testing, and binary data manipulation. Features atomic collections, map-to-JS object conversion, coroutine combiners, and interval flows.

Enables asynchronous queue management with fine-grained concurrency control, ideal for combining asynchronous and synchronous operations. Supports parallel processing while ensuring sequential execution for specific keys.

Offers tools for managing and maintaining continuous integration and deployment workflows, enhancing automation processes and streamlining project development cycles.

Compute streaming, mergeable statistics using constant memory: summaries, quantile and cardinality sketches, decaying/regression estimators, composable adapters, wire-portable schemas, and bandits.

Lightweight read-write mutex implementation inspired by Golang's `sync.RWMutex`. Utilizes extension functions for simplified read/write lock management and state checking.

Listener-based logging framework with asynchronous, thread-safe dispatch, multiple log levels, regex-based tag/message filtering, emoji console output, daily rotating file logs with cleanup, and custom listener support.

Lightweight network client facilitates multithreaded HTTP requests, utilizing NSUrlSession for iOS and OkHttp for Android. Supports custom headers, JSON decoding, and advanced multithreading techniques.

High-performance, lock-free bounded priority queue using persistent treap and CAS-based atomic updates; automatic eviction, key-based upsert deduplication, O(1) lookup, reactive state and batch mutations.

Minimal logging library offering an easy, extensible API with multithread support. Inspired by Timber, enables logging using static methods throughout applications.

Implements a straightforward EventBus using SharedFlow, inspired by Greenrobot EventBus. Features publish/subscribe, request/response patterns, and compile/runtime channel handling for event-driven communication.

Context for asynchronous job execution with observable state, results and errors; declarative reactive API with Task/WatchContext/JobFlow abstractions, lifecycle control, lazy scheduling and cancellation.

Core foundation delivering type-safe environment detection, UUID V4/V7 generation, DSL markers and opt-in annotations, plus lightweight, concurrency-ready utilities for consistent ecosystem development and small footprint.

Global reactive cache with TTL, queries/mutations/flows and infinite pagination, transactional optimistic updates with rollback, stale-while-revalidate, per-key locking, factory-based APIs, type-safe errors and refetch.

Versatile caching solution enabling automatic refresh, expiry handling, and network-aware adjustments. Supports customizable fetching strategies, thread-safe operations, and shared resource management across classes.

Manages remote data state with sealed Loading/Success/Error model, reactive flows, type-safe transitions, mapping utilities (mapSuccess/mapError), atomic success updates and zero-dependency implementation.

Facilitates creation of finite state machines with single active state, ensuring thread-safety and eliminating concurrency issues. Enhances readability, testability, and observability through structured state implementation and transition monitoring.

Per-object thread-local storage: ThreadLocal type supplies independent per-thread object copies; faithful line-by-line transliteration of upstream crate, port-lint provenance headers, feature-parity in-progress.

Event-driven, non-blocking asynchronous runtime featuring multithreaded work-stealing scheduler, reactor, async TCP/UDP and runtime primitives; faithful line-by-line transliteration of upstream implementation with provenance headers.

Facilitates POSIX signal handling with multithreading capabilities, enabling efficient signal management across multiple threads.

Facilitates mutex operations across multiple platforms, enabling synchronized access to shared resources. Enhances thread safety and concurrency control with straightforward integration.

Architectural framework manages state and event processing, utilizing parameters, projections, events, intents, and event chains to ensure code predictability, testability, and scalability.

Implements concurrent collections and atomic primitives like `ConcurrentSet`, `ConcurrentMap`, `AtomicBoolean`, and `AtomicReference`, enhancing thread-safe operations across platforms.

Represents session management, allowing multiple starts and ends while holding and atomically updating data. Notifies observers on data changes and supports synchronous or streaming data retrieval.

Fast, minimalistic object pool designed to manage object allocation efficiently. Supports a thread-local version and discards excess objects. Not inherently thread-safe.

Encapsulates shared mutable state, allowing transactional operations and safe reads without mutexes. Supports diff filtering for efficient, thread-safe management of large, frequently updated data.