Browse Kotlin Multiplatform libraries

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.

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.

Modern architecture toolkit offering ViewModel foundations, coroutine-based UseCase/FlowUseCase framework, Compose-friendly State/StateFlow UI patterns, Decompose navigation support, and Hilt/Koin DI conventions.

Library for embedding NoSQL JSON document databases with features like SQL++ queries, observable entities, binary attachments, and data synchronization. Provides extensive API support for SQL++, key/value, full-text search, and peer-to-peer sync.

Offers graphics primitives for common code, including color conversion to platform-specific formats like ARGB and RGBA. Simplifies cross-platform graphics handling with straightforward installation and usage instructions.

Simplifies handling non-nullable values in various contexts including Bundles, Intents, and WorkManager Data by providing utility functions that throw meaningful exceptions when values are missing or of the wrong type.

Code-first toolkit for building, evaluating, and deploying sophisticated AI agents; offers rich tool ecosystem, modular multi-agent orchestration, built-in development UI and cloud integrations.

Syntax highlighting components for composing code views and editors, supporting various programming languages, themes, and text formatting. Enables code component analysis and incremental updates with customizable views.