Browse Kotlin Multiplatform libraries

Declarative UI toolkit enabling programmatic UI via composable functions, offering animations, Material (including Material 3), foundation building blocks, compiler optimizations, runtime state management, and core UI primitives.

Real-time composable stability analysis with editor gutter icons, hover tooltips, inline parameter hints and code inspections; runtime @TraceRecomposition logging plus Gradle tasks for recomposition tracing and reports.

A compiler plugin simplifies writing and maintaining data model classes for public APIs by auto-generating `toString`, `equals`, and `hashCode` functions, with optional array content-based checks.

Enables declarative UI and application screen management in common code, ensuring compile-time safety and reactive data handling. Facilitates full application implementation from common code, adhering to platform rules.

Compiler plugin embeds metadata about source files directly into the generated code, allowing access to filename, enclosing type, member name, and line number at runtime.

Unit testing library facilitates parameterization of tests using enums, specializing test cases for each enum value and combination, enhancing test coverage with minimal code changes.

Tool designed to trace and report recomposition issues in Composables, tracking changes in arguments and state values without boilerplate. Currently under redevelopment.

Facilitates deep copying and updating of data class properties using `copy` or `invoke` functions. Adds new functions and properties, supports lambda updates, and enhances immutability without reflection.

Enhances type casting by introducing `unsafeCast`, allowing reinterpretation of nullable references as non-nullable without runtime checks, optimizing performance at the expense of type safety.

Compiler plugin reducing APK size by optimizing data class methods like `toString`, `equals`, and `hashCode`. Configurable modes control method generation while retaining compatibility with bytecode optimizers.

Simplifies dependency injection with compile-time validation and faster compilation by generating code for dependency resolution. Features include constructor-based injection, singleton management, and module scoping without runtime file generation.

Next-gen dependency injection library offering a streamlined approach to providing and injecting dependencies, supporting multi-injection, scoping, modules, components, function injection, and type distinguishing strategies.

Generates blocking bridges for calling suspend functions from Java, simplifying integration. Automatically creates non-suspend bridge functions, ensuring minimal effort and high stability for production use.

Generates `Parcelable` implementations for Apple targets, enabling serialization/deserialization similar to Android's `kotlin-parcelize`. Supports various data types and custom parcelers, facilitating cross-platform code sharing.

Tracing, monitoring and evaluating AI features via a unified API that captures structured traces, follows OpenTelemetry Generative AI semantics, auto-instruments popular AI clients, and exports to observability backends.

Compiler plugin generates platform-compatible functions for suspend functions, allowing seamless integration and usage of asynchronous code in synchronous contexts across different platforms.

Implements Gettext for internationalization, featuring a library for string translation, a compiler plugin for extracting translatable strings, and a Gradle plugin for seamless integration, enhancing i18n workflows.

Enables capturing string variables before interpolation, enhancing security and flexibility. Implements custom DSLs for safe SQL queries, preventing SQL injection vulnerabilities through typed string interpolation.

Generates compile-time type-safe test fakes with zero runtime overhead, no reflection, thread-safe call tracking, smart defaults and compiler-plugin code generation for comprehensive test doubles.

AOP framework enabling method replacement at compile-time through custom hooks. Offers runtime support, original method invocation, and inlining for reduced dependency issues. Supports specific platforms.

Compile-time reflection enabling inspection of classes, functions, properties and annotations, with top-level declaration support, suspend invocation, JVM-like proxies and dependency reflection.

A compiler plugin enabling dynamic class delegation similar to property delegations, which simplifies delegation and allows functions to be 'lazy' with persistent values, enhancing flexibility and reducing boilerplate.

Minimalist faking framework focuses on verifying interactions by generating fake implementations for interfaces and abstract classes, promoting better class design without supporting full mocking.

Compile-time aspect-oriented weaving via compiler IR transformation, injecting @Aspect/@Before advice with zero runtime overhead; supports suspend, inline, extension, expect/actual functions, inheritance, many-to-many targets, rich JoinPoint metadata.

Enables JSON-like RPCs with simple service declarations, supporting various connection mechanisms. Integrates annotations for service mapping, and provides a flexible environment setup for hosting services.

Generates JSON schemas from annotated classes, supporting primitives, arrays, maps, nested objects, and enums. Ensures type-safety with KDoc subset and handles nullable fields. Experimental API.

Enhances lambda performance in inlined functions by optimizing their storage in local variables. Enables struct emulation in code with no extra cost. Currently experimental.

Offers a positional code API and introspection framework with features like `SourceLocation`, `FunctionInfo`, `ClassInfo`, and `AnnotationInfo` for enhanced introspection and compile-time evaluation.

Enhances interoperability with Java by allowing nulls for default parameters through annotations, automatically substituting default values. Primarily supports legacy Java code, maintaining Kotlin conventions.

Enhances API contracts for JavaScript clients by generating JS-friendly functions and class constructors. Enables passing arguments via destructured objects, improving code readability and reducing bugs.