Browse Kotlin Multiplatform libraries

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.

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.

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.

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.

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.

Runs as an MCP server over stdio, implementing audio processing, subtitle‑to‑LRC and WAV→MP3 conversion, shell command execution, image understanding via Vision API, plus resource/prompt declarations.

Detects runtime environment as an enum, exposes currentPlatform constant, offers lightweight, easy-to-integrate API and extensible hooks for telemetry-friendly platform metadata.

Native touchscreen and stylus integration for Compose apps: smooth 1:1 panning, inertial fling scrolling, tap-to-click synthesis, modal priority hit-testing, and layered touch modifiers.

Unified Raylib API with automatic C-header code generation to produce language bindings, sample applications, and build tooling for creating statically-linked games and streamlined debugging.

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.

HTTP mocking for testing apps: start isolated mock servers, define rich request matchers, template dynamic responses, set invocation expectations, and pool servers to speed tests.