Browse Kotlin Multiplatform libraries

Expose image, audio and video codec utilities: get image info, audio→PCM decoding, Silk encode/decode, PCM duration, video info and first-frame JPEG extraction — handy for QQ protocol work.

Unified file-system abstraction with stream-first APIs for discovering, reading, and writing files, recursive extension-filtered discovery, storage access framework support, stack-based traversal, and lightweight platform detection.

Native TDLib wrapper exposing JSON-based send, receive and execute APIs, automatic native library extraction/loading, JNI and cinterop bridges, prebuilt native cache and build tooling.

BlueZ-backed engine integrating with Blue Falcon BLE core over D-Bus; offers scanning with UUID filters, connect/retry, GATT discovery, read/write, notifications, descriptors, and bonding support.

Terminal manipulation toolkit: cursor control, rich color/styling (16/256/RGB) and attributes, screen/raw-mode management, event polling (keyboard, mouse, resize), command-pattern ANSI batching.

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.

LR(1) parser generator implementing the lalrpop grammar and architecture, offering a configuration API to process .lalrpop grammars, Cargo-style conventions and code generation.

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.

Ergonomic trait-object error type for idiomatic application error handling; attach contextual messages, downcast to concrete error types, capture backtraces, and create errors with concise macros.

Immutable, cheaply-cloneable byte containers and cursored read/write views; typed big- and little-endian numeric access, chaining/limiting adapters, iterator/reader/writer adapters, Result-based safe reads.

Line-by-line transliteration of a mature parser-generator, enabling compact readable grammars, reusable grammar macros, operator and type-inference support, compact defaults, and LR(1)/LALR(1) parsing.

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.

Retrieves system IANA time‑zone identifier as a string, exposing a tiny API for reliably resolving tz database names with faithful upstream behavior and minimal dependencies.

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.

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.

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.