Browse Kotlin Multiplatform libraries

Type-safe, ergonomic flagset declarations with concise APIs for defining, combining, iterating, and converting flags; faithful transliteration of established flagset semantics.

Locate installed executables on PATH across environments; supports regex-based searches, enumeration of multiple matches, and configurable system backends for custom environment handling.

Compact, insertion-order-preserving hash table enabling lookup by key or numerical index, fast iteration, and memory-efficient dense storage; order only changes with removals or swap operations.

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.

Line-by-line transliteration of a NaCl-compatible implementation offering crypto_box public-key authenticated-encryption primitives, aiming feature parity and embedding upstream provenance headers for traceable ports.

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.

Unicode-aware string segmentation: iterators for grapheme clusters, words and sentences per UAX#29; includes GraphemeCursor for random/bidirectional access, word indices and performance optimizations.

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

Line-by-line transliteration of the upstream project reproducing Bash grammar and API parity, embedding port-lint provenance headers for AST tracking and aiming strict behavioral fidelity.

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.

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.

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.