Browse Kotlin Multiplatform libraries

Constant-time comparison of equal-length byte strings to prevent timing attacks; faithful line-by-line transliteration of upstream implementation, includes provenance headers, tests, and CI.

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.

Line-by-line transliteration of a mature image library, offering format decoding/encoding, ImageBuffer/DynamicImage types, imageops (blur, resize, rotate), and provenance-tracked source mapping.

Faithful line-by-line transliteration of a UUID implementation enabling generation, parsing, formatting, version handling, and per-file provenance headers for traceability, aiming feature parity with upstream.

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.

Declarative data fetching with caching and stale-while-revalidate, reactive background refreshes, lifecycle-managed registry, and dedicated mutation actions for synchronized async state and side effects.

gRPC over HTTP/2 implementation with protobuf-based codegen, high-performance async IO, bi-directional streaming, TLS support, load balancing, health checking and reflection utilities.

Line-by-line transliteration of an SSE stream parser, converting byte-array streams into Server-Sent Events; includes provenance headers and strict porting discipline for traceability.

VT100/ANSI terminal escape-sequence parser and emulator, faithful line-by-line port of an upstream implementation; preserves behavior, exposes a native API and embeds source headers for provenance tracking.

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

Line-by-line transliteration of an upstream tracing↔OpenTelemetry integration, adding OpenTelemetry context to spans, injecting/extracting trace data, setting attributes/status, events, and optional metrics export.

Line-by-line transliteration of an upstream crate offering raw Windows API FFI bindings, feature-gated modules, and port provenance headers for upstream-to-port tracking, aiming for feature parity.

MIME type guessing from file extensions using a static extension-to-MIME map; supports multiple MIME types per extension, returning the first as the preferred match.

Match file paths using Unix shell-style globs (*, ?, [], {}, **) with efficient single-pattern and glob-set matching, optional case-insensitive and literal modes, and path-separator awareness.

Line-by-line transliteration of a map-literal library, delivering concise map construction macros and API parity with the original, plus strict provenance tracking via port-lint headers.

Line-by-line diffing utilities for finding and manipulating file differences, with provenance-tracking source headers and faithful upstream behaviour for reproducible, inspectable diffs.

Detects text character encodings robustly using a line-by-line, streaming algorithm; faithful transliteration of an established implementation, aiming feature parity and an idiomatic native API.

Efficient, generic serialization/deserialization framework with derive-style codegen, pluggable data-format adapters, and faithful line-by-line transliteration including per-file provenance headers, ensuring API parity with upstream implementation.

High-performance lexer generation using compile-time DFA construction, combined token definitions, lookup/jump-table optimizations, regex and literal tokens, loop unrolling, and no-backtracking.

Generate TypeScript declarations from Rust types, including enums, generics and serde-aware mappings; export bindings to files with import resolution and configurable large-integer handling.

Line-by-line transliteration of an upstream identity tool, exposing system identity info (user, host, OS) with a native API, feature-parity, provenance headers and porting discipline.

Loads and parses .env-style key-value files with non-modifying and environment-modifying APIs, configurable loader, reader support, multiline/substitution handling, and compile-time/runtime loading options.

Line-by-line transliteration of a battle-tested base64 implementation offering high-performance encoders/decoders, engine-level APIs, canonical-padding handling, and configurable decoding for non-canonical inputs.

Handles push and local notifications via Firebase Cloud Messaging with simple initialization, configurable foreground display, image support, runtime permission helpers and unified API.

High-performance bindings to libschnorr256k1 offering optimized secp256k1 BIP-340/Nostr APIs: key generation, Schnorr signing/verification (fast and batched), ECDH, SHA-256, automatic native loader.

Line-by-line transliteration of Starlark syntax: parser, AST and tooling matching upstream Rust, with provenance headers, AST-distance tracking and strict porting discipline.

Chunked multipart uploads to cloud storage with pause/resume, retry and persistent upload state across restarts. Enqueued background engine, per-chunk progress stream, and pluggable HTTP callbacks.

Unified networking fabric with session API, swappable transports, replicated CRDT data structures, Raft consensus and leadership, turn-based game and fair-deal utilities, conformance tests.

Elegant, type‑safe, locale‑aware date/time, interval, relative‑time, duration and period formatting via readable DSLs; smart interval merging, customizable formats, and implicit locale/timezone scoping.

Port of the ANTLR v4 runtime translating Java sources into a portable implementation, enabling ANTLR-generated parsers; runtime API parity work ongoing.