Browse Kotlin Multiplatform libraries

Buffer-based IO primitives: queue-like mutable byte sequences, immutable ByteString, Source/Sink abstractions, linked-segment pooling for reduced allocations, and experimental filesystem/path APIs.

Embeds ICU data (icudtl.dat) for deno_core, delivering a faithful line-by-line transliteration port with port-lint provenance headers, native API support, and upstream parity.

Line-by-line transliteration of upstream SDK delivering real-time video, audio and data channels, simulcast, SVC codecs, hardware-accelerated encoding/decoding, and server APIs.

Command-line argument parser offering declarative and procedural APIs, builder-style DSL, subcommands, validation, and rich flag/option handling — faithful, feature-rich port of a mature upstream design.

Safe bindings for Landlock LSM system calls to create per-process filesystem sandboxes, with faithful line-by-line transliteration, provenance headers, and helper APIs for rulesets and path rules.

Line-by-line transliteration of rust-lang/log delivering a lightweight logging facade with log levels, macros, and pluggable logger registration, aiming for faithful API parity.

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

High-performance fuzzy matcher implementing Smith–Waterman with affine gaps; Unicode-grapheme aware, ASCII-optimized, aggressive prefiltering and fast heuristic fallback for very long matches.

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.

Line-by-line transliteration of an upstream search-tool ignore crate: gitignore/.ignore/.rgignore parsing, glob and regex path matching, ignore-rule application, fast parallel recursive directory traversal, provenance headers.

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.

Line-by-line transliteration port of a mature Encoding Standard implementation. Streams and buffers convert between legacy encodings, UTF-8 and UTF-16, with mem utilities, label resolution and optional SIMD acceleration.

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.

Unified, coroutine-native API to manage home-screen quick actions with system icon mapping, pinning requests, usage reporting, hot activation stream, and a test-ready fake manager.

Native WebView-based PDF viewing with direct URL loading, smooth scrolling, pinch-to-zoom, page indicators, dynamic titles, LRU bitmap caching, lifecycle-aware back navigation, coroutine-friendly API.

Turn-by-turn navigation logic enabling self-hosted map tiles and directions API, UI-free, telemetry disabled, customizable route-request interceptor and pluggable location engine.

Reliability-first background-task API offering scheduling, retries, SQL-persistence, offline queue with replay, task chaining, tag-based cancellation, state flows and test fakes.

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.

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.