Browse Kotlin Multiplatform libraries

Lightweight implementation of OpenID Connect/OAuth 2.0 supporting Authorization Code Grant Flow, discovery, PKCE, and simple JWT parsing. Includes Android, iOS, desktop support, and OkHttp/Ktor integration.

Enhance apps with vibrant, customizable confetti animations using a lightweight library. Features include adjustable speed, direction, colors, shapes, and seamless integration with Compose.

Multiplatform 3D graphics rendering engine utilizing OpenGL for seamless integration into Compose UI. Supports rendering, lighting, shadow mapping, texturing, custom shaders, and basic GUI elements.

Simple API converts HTML to AnnotatedString with styling for UI components, replacing traditional HTML parsers. Supports custom styling, hyperlink handling, and unstyled text conversion. Future goals include inline image display.

Enhances Compose with `rememberRetained{}` for state management within ViewModel. Simplifies UI and foundational component creation. Retains state across configuration changes and back stack navigation.

Plugin and library facilitate reading test resources using a unified API. Provides `Resource` class for checking existence, reading text, and reading bytes from designated resource folders.

Flexible API enables building custom design systems with unique design tokens and properties. Offers default colors, text styles, shapes, and easy theming. Supports extending properties and debugging capabilities.

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.

Creates a composable table with automatic layouts, supporting 2D scrolling, custom cells, sticky rows/columns, and infinite dimensions. Lacks lazy cells and grid lines. Easy to use and highly customizable.

Offers a diverse set of data structures, algorithms, and utilities to enhance OPENRNDR, including tools for 2D/3D cameras, color management, shape composition, animation easing, noise generation, and various computational techniques.

Easy-to-use serialization plugin for encoding and decoding TOML 1.0.0 compliant data. Supports various data types, including comments, strings, dates, and arrays. Allows dynamic TOML table construction and custom serialization configurations.

Set of libraries for working with geospatial data, including GeoJson implementation and a port of Turfjs, featuring a Kotlin DSL for building GeoJson objects.

Beautiful production-ready UI components and theme system, over 40 customizable primitives, optional CLI copies components into source for full ownership and unlimited customization.

Monitors file system changes across multiple directories, emitting events such as create, delete, and modify. Allows observing file events using flows, supports multiple platforms, and provides raw event access for debugging.

Enables content zooming with dragging, double-tap, and swipe-to-dismiss gestures. Features over-zoom effects and seamless integration with horizontal pagers, enhancing image viewing quality and interaction.

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.

Implements client-side gRPC with support for parsing proto3 files, generating corresponding code, and suspending RPC calls. Features a DSL for creating proto objects and supports various proto types.

Facilitates scheduled task execution at runtime using a flexible, cron-like syntax. Supports configuration via strings or DSL builders, local and timezone-aware scheduling, and conversion to reactive flows.

Block-based, Notion-style editing: draggable blocks, slash commands, rich-text spans, custom block types, drag-and-drop reordering, versioned JSON serialization, extensible registry and theming.

Offers a microframework with customizable navigation components and an application architecture module. Supports app startup, plug-in integration, and manual or Koin-based dependency injection.

Minimalistic reactive library implementing TEA/ELM architecture, enabling scalable and reusable components, single immutable state management, and unidirectional data flow.

Generate JSON Schemas and LLM function-calling schemas from functions and models—including third-party classes—via compile-time zero-overhead generation or runtime reflection; annotation-aware and OpenAI/Anthropic-compatible.

Enables pragmatic, type-safe navigation with features like ViewModel integration, SavedStateHandle support, lifecycle management, multi-backstack, and custom transitions. Automatically saves and restores navigation stack states.

Introduces support for universally unique identifiers (UUIDs), offering serialization capabilities and compatibility across various platforms. Integrates seamlessly with existing serialization libraries for enhanced data handling.

Testing API for creating readable, fluent assertions inspired by Google Truth. Allows writing `assertThat` checks, custom messages, and exception assertions, producing cleaner error messages.

Adds basic support for Unicode code points by exposing methods from `java.lang.String`, `java.lang.StringBuilder`, and `java.lang.Character`, including `CodePoint` class for enhanced usability.

Enables in-IDE preview of user interfaces across different platforms, enhancing cross-platform development efficiency by providing real-time visualization and adjustments without leaving the development environment.

Facilitates efficient display of tiled maps with support for markers, paths, and gestures like flinging, dragging, scaling, and rotating. Features marker clustering and multi-layer capabilities, ensuring responsive and smooth map interactions.

Simplifies object mapping code generation by providing a compile-time solution, enhancing development efficiency and reducing errors. Offers type-safe, idiomatic code with intuitive error messages and compatibility with various platforms.

Enforces structured concurrency for coroutines via compiler checks, static analyzers, IDE inspections, lint rules and annotations — compile-time errors, quick fixes, tool window, zero runtime overhead.