Browse Kotlin Multiplatform libraries

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.

Compose library for displaying customizable epic calendars. Features include basis calendar setup, calendar pagination, date picking with single, multiple, and range selection modes, and drawing date ranges. Offers global configuration capabilities.

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.

Run JavaScript code asynchronously with simple, idiomatic APIs. Integrates with coroutines, supports bindings, ES modules, and provides robust error handling and type mappings. Ideal for flexible, cross-platform development.

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.

Light ORM enabling type-safe SQL with idiomatic syntax. Supports JDBC, R2DBC, Vertx sqlclient, and various databases including PostgreSQL, MySQL, and SQLite. No annotations or code generation required.

Fully customizable slide-to-unlock UI component enhances apps with seamless integration, intuitive customization options, and dynamic, interactive features for diverse styling possibilities.

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.

Meeseeks is a Kotlin Multiplatform library for scheduling and managing background tasks across Android, JVM, native (iOS), and JS (Web). Whether your tasks are simple or complex, for one user or hundreds of millions, Meeseeks can help.

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

Enhances Gradle projects with dynamic web reports for static analysis, revealing module dependencies and dependents. Supports custom analysis plugins and continuous updates via GitHub Actions.

Grid layout ensures each item's aspect ratio is preserved, preventing distortion. Features smart row distribution, height protection, and responsive design for seamless image layouts.

Comprehensive library facilitating the use of International System of Units in code, enhancing formula writing, dimensional analysis, and error detection in complex calculations without external dependencies.

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.

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.

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.

Dependency Injection library facilitates easy provision and management of dependencies using annotations, supports compile-time dependency graph checks, and integrates with KSP for code generation.

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.

Compiles AT Protocol schemas into usable classes, provides APIs for the AT Protocol spec usable with services like Bluesky Social, and includes example client apps demonstrating API usage.

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.