Browse Kotlin Multiplatform libraries

Shared core logging API with formatter DSL, customizable formatting and tagging, caller-aware resolution, per-line levels, console/file loggers, and extensible logger interfaces.

Configures Sentry with privacy-focused defaults: disables auto-install, performance tracing, session tracking; anonymizes user/device, preserves only last-screen breadcrumb, and attaches build metadata to crashes.

Ordered B-tree map and set implementing Rust std semantics, preserving upstream behavior and tests; offers stable-order iteration, efficient B-tree operations, and parity-oriented translation.

Wrapper around compiler's procedural-macro API, enabling proc-macro-like token streams outside macros, making macro logic unit-testable; faithful line-by-line transliteration preserving upstream behavior and provenance.

Line-by-line transliteration of an upstream map implementation, delivering faithful feature-parity collections with port-lint headers for provenance tracking and translator guidelines enforcing disciplined ports.

SSE HTTP-body codec decoding server-sent events into event streams and encoding SSE events into HTTP bodies; faithful line-by-line transliteration of upstream Rust implementation.

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

Faithful Rust proc_macro API port backed by a real-language lexer producing TokenStream/Span/TokenTree with accurate syntax spans, enabling source-aware codegen and Rust→source translation.

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.

Line-by-line transliteration of ICU4X decimal internationalization APIs, delivering locale-aware formatting with upstream feature parity and provable provenance via per-file port-lint Rust source headers.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 upstream age implementation enabling age-format file encryption: recipient and passphrase encryption, SSH key support, multiple recipients, plugin integration; faithful port provenance via port-lint headers.

Extensible, strongly-typed OAuth2 implementation supporting RFC 6749 flows, token handling, and pluggable configuration; faithful line-by-line transliteration aiming for full feature parity with upstream.

Line-by-line transliteration port offering Async adapter for standard networking types, Timer futures, and a background reactor thread that polls OS I/O events and wakes awaiting tasks.

Fast MMKV-compatible key-value store offering a unified, type-safe API, MMKV binary format, drop-in preferences adapters, null-on-miss getters, synchronous C++ core and no reflection or annotation processors.

Enables async methods in interfaces via generated adapter types and shims; faithful line-by-line port with provenance headers and strict porting discipline.