Browse Kotlin Multiplatform libraries

Sealed state types modeling common UI transitions — loading, saving, mutating (with original/updated tracking), plus ResourceState that combines load/save flows for predictable, type-safe view-state handling.

Simple, lightweight zipcode validator offering regex-based checks and easy export to JavaScript and Java, enabling quick integration and minimal footprint for client or server-side usage.

Predictable fixed-size 64-bit decimal type with 60-bit mantissa and 4-bit exponent; supports arithmetic, comparisons, configurable automatic rounding, and locale-aware parsing/formatting.

Lightweight functional extensions for nullable handling, suspend-friendly mapping, type-safe casting, null-aware matching, and lift combinators for combining nullable values with concise chaining.

Byte-array manipulation utility offering wrapping, indexed put/get, little-endian integer read/write, buffer-style operations, and simple extraction of the underlying byte array.

Extension utilities for reactive Flow streams: concise operators, converters, lifecycle-aware collectors, enhanced error handling, caching and testing helpers to simplify stream composition, transformation and consumption.

Lightweight utility extensions offering nullable defaults, safe string conversion, list/map manipulation (rotation, chunking, inversion), shared JSON serialization helpers, and callback-based exception handling.

Quasi-quoting toolkit enabling code-as-data generation of token streams via quote-like macro syntax: interpolation, repetition, identifier construction, span-aware hygiene, and composable token fragments for code generation.

Ergonomic trait-object error type for idiomatic application error handling; attach contextual messages, downcast to concrete error types, capture backtraces, and create errors with concise macros.

Immutable, cheaply-cloneable byte containers and cursored read/write views; typed big- and little-endian numeric access, chaining/limiting adapters, iterator/reader/writer adapters, Result-based safe reads.

Collection of well-tested utility extensions and types: ergonomic collection/string helpers (Vec.map, split1), a cheap-copy Dupe trait, and ARef abstraction for uniform references.

Line-by-line transliteration of a mature parser-generator, enabling compact readable grammars, reusable grammar macros, operator and type-inference support, compact defaults, and LR(1)/LALR(1) parsing.

Pure Open Location Code implementation to encode, decode, shorten, recover and validate Plus Codes. Strong type-safety via zero‑overhead value type; passes official Google test vectors.

Lightweight runtime permission handler with simple callback API, multiple and sequential requests, permanent-denial detection, location/background permission support, and Compose-ready integration.

Chainable string-validator supporting numerous predefined and custom rules, builder pattern, translations, date formats, message localization, utility alphabets/regex, compare and copy features.

Lightweight logging API for libraries plus advanced engine for apps — tag-based routing with wildcard filters, independent importance tiers, and frequency controls (rate-limit, dedupe, sampling).

Zero-allocation, zero-cost terminal colorization with compile-time and runtime RGB/Xterm/ANSI colors, styling, format-trait support, optional terminal detection, NO_COLOR/FORCE_COLOR overrides, dependency-less, const-friendly API and hand-picked color names.

Retrieves cryptographically-secure random bytes from the OS RNG via a single getrandom(dest: ByteArray) call, delegating to native entropy sources for a minimal API and small footprint.

LRU cache implementation offering O(1) put/get/get_mut/pop; faithful line-by-line transliteration of an upstream implementation with provenance headers and goal of feature parity.

Retrieves system IANA time‑zone identifier as a string, exposing a tiny API for reliably resolving tz database names with faithful upstream behavior and minimal dependencies.

Line-by-line transliteration of enum-string utilities — derive string↔enum conversions, iteration, variant metadata, discriminants, counts, and generated helpers for easier enum parsing and display.

Unix shell-style file path pattern matching with recursive globs, iterator-based results, and faithful line-by-line transliteration from an upstream implementation, preserving original behavior and provenance tracking.

General-purpose HTTP types and builders — requests, responses, headers, status codes — line-by-line transliteration of upstream crate with provenance headers and idiom mapping for parity.

Read and set system properties via a concise API; create property-accessor instances and fetch values (e.g., persist.sys.timezone) with minimal boilerplate.

Associative container mapping keys to multiple values, supporting insert/insert_many, flat iteration, customizable hasher and FromIterator conversion — a thin HashMap-backed multimap implementation.

Single-assignment cell and Lazy types enabling one-time initialization with direct references; unsynchronized and synchronized variants provide safe concurrent lazy initialization and ergonomic API for global/static data.

Asynchronous programming foundations: futures, streams, combinators (join!, select!) and utilities enabling ergonomic async control flow; faithful line-by-line transliteration preserving upstream semantics and source provenance.

Geospatial toolset: GeoJSON DSL with builders and JSON serialization, ported Turf.js spatial-analysis functions, plus unit-of-measure types and formatting utilities for distances.

Extra iterator adaptors, combinators and utilities for fluent sequence processing — combinations, permutations, grouping, chunking, sliding windows, zipping, unique, cartesian products.

Generate JSON Schema documents from data types, honoring serialization attributes, offering derive-style macros, schema-from-value generation, serde-compatible behavior, and Draft 2020-12–compliant output.