Browse Kotlin Multiplatform libraries

Lightweight logging framework offering a performant logging facade with lazy-eval string logging, exception handling, and fluent logging style. Simplifies logger initialization and supports various SLF4J implementations.

Offers structured logging with configurable log levels, tagging, and output destinations. Supports logging to console, file, and custom destinations with flexible configuration options.

Logger library supports multiple platforms, displaying logs on each platform's native viewer. Features include customizable log levels, throwable logging, and integration with Crashlytics.

Tiny API enhances Android logging by simplifying log calls with string interpolation and efficient tag generation. Eliminates unnecessary overloads, providing a streamlined logging experience.

Flexible logging library designed for creating structured log events, leveraging coroutines for asynchronous event dispatch, and supporting high-resolution timestamps. Includes adapters for SLF4J, Spring Boot, and Hexagon frameworks.

Lightweight, extensible logger library for managing, printing, and persisting runtime log messages. Supports platform-specific loggers, composite loggers, and validators for customized logging behavior.

Real-time audio, video and signaling stack with WebRTC integration, CLI client (zcall), build tooling, static libraries and standards-compliant features like trickle-ICE, STUN consent freshness, data channels.

Multiplatform logging library targets Android, iOS, JVM, JS and Wasm, utilizing native logging facilities. Offers high performance, minimal overhead, customizable log levels, and thread-safety without requiring configuration.

OpenTelemetry spec implementation offering both a native implementation and a compatibility façade over the Java SDK, with tracing, logging, and API/noop instrumentation modules.

Logging library experiment with a usage pattern similar to Timber, featuring platform-specific implementations and custom seedlings. Supports automatic log tagging, Kotlin extensions, and seamless migration from Timber.

Facilitates lazily-evaluated log calls using inline classes and functions, integrating with SLF4J. Supports idiomatic logger declarations, resistant to cut-and-paste errors, and improves logging performance by avoiding unnecessary computations.

Personal cloud computer for storing photos, media and documents, running sandboxed WebAssembly apps (password managers, smart‑home, trackers), portable between hosts, pay‑as‑you‑go storage and backups.

Implements OpenTelemetry specification, acting as a facade for the Java SDK, with future plans for a native implementation. Supports tracing and logging APIs.

Implements verifiable credentials for issuing, presentation, and validation across various applications, supporting W3C and ISO standards, ARIES protocols, OpenID, and customizable cryptographic operations.

Minimalistic logging library facilitating initialization, log level configuration, and various logging sinks (AndroidLog, Println, MemoryRing). Supports convenient log methods for info, debug, warning, and error.

A comprehensive logging and tracing platform designed for asynchronous, scalable event-driven systems. Ensures OpenTelemetry compatibility, supports SLF4J integration, and prevents log flooding with dynamic rate-limiting.

Generates GraphQL document wrappers and type-safe query classes integrated into build tasks. Supports custom type mapping and can be used with HTTP clients for seamless GraphQL API interaction.

Client library for interacting with the Notion API, offering coroutine-based, blocking, and future-based flavors. Facilitates OAuth support, pagination, content creation with DSL, and configurable logging/proxy settings.

Portable utilities: sprintf-style formatting with advanced flags, base64 (including URL-safe), fast Boyer–Moore byte search, ByteArray int ops, cached expressions, reentrant coroutine mutex, coroutine-based async logging.

Cross-platform logging library mimics Android's Log API, supports live log broadcasting, configurable log levels, and real-time monitoring via a client application using mDNS and WebSocket.

SocketIO client implementation enables asynchronous socket creation, streamlined thread safety, and simplified binary message handling. Offers logging integration and example usage across multiple platforms.

Facilitates efficient logging with customizable filters, loggers, and formatters. Supports advanced features like tagging, serialization, and easy integration into existing projects.

Lightweight logging library with a simple API, supporting multiple platforms. Facilitates easy logging setup, multi-level logging, and seamless integration with platform-specific frontends.

Span-aware tracing with structured, low-overhead logfmt lines carrying trace/span IDs; reconstructs end-to-end call trees via CLI, supports context propagation across threads/async hops and pluggable backends.

Monitors HTTP requests, records exceptions, and inspects Room databases in real-time. Offers Room database inspection and custom query execution. Inspired by Chucker, but extends functionality.

Lightweight logging library enabling flexible log management with console and file logging, SLF4J integration, custom loggers, and efficient handling of expensive computations across various platforms.

Streamlines remote configuration management, offering flexible syntax for declaring configuration elements, multiple data sources, and debugging capabilities. Supports feature-specific configurations with logging and interception functionalities.

Empowers developers to create and manage AI agents with a streamlined DSL, offering error handling, logging, and integration with the ecosystem to transition from PoC to production.

Android-style d()/i()/w()/e() logging with tag-first design, zero-configuration, coroutine-safe and thread-safe; composable loggers (combine), easy custom implementations and straightforward Java interoperability.

Supports querying JSON data using JSONPath expressions, enabling node selection and path normalization. Allows adding and removing custom function extensions while leveraging popular libraries for logging, testing, and serialization.