Browse Kotlin Multiplatform libraries

Generates Java-friendly APIs from suspend functions, creating Future-based interfaces for seamless integration with Java and other JVM languages, while retaining original suspend functionality.

Lightweight micro-ORM enabling explicit SQL-driven data access with mandatory transaction scopes, convenient DSLs, parameter mappers, and an optional compiler plugin to auto-generate row mappers.

Minimal placeholder repository awaiting documentation; scaffolds codebase and configuration, intended for future features and contributions, currently lacking descriptive README and usage examples.

Enhances build processes by propagating CODEOWNERS information to classes. Offers plugins for reporting class ownership, JVM runtime propagation, and Kotlin runtime propagation, supporting multi-module projects.

Tool for compile-time transformation of intermediate representations, enabling method entry/exit hooks or complete replacements using annotation-based mechanisms to modify and enhance method functionalities.

Enhances coroutine context management in suspending functions through annotations, simplifying code readability by eliminating the need for `withContext` calls.

Compile-time AOP that replaces functions, constructors and properties with zero runtime reflection and no performance cost; supports before/after/NULL hooks, callOrigin/getField/getThisRef and inline hooks.

Compiler-plugin stack enabling typeclass-oriented programming via context parameters; implicit evidence search, rule-style instances, derived instances, proof materialization, and Gradle/IDE integration.

Placeholder repository README indicating documentation pending; intended to later include installation, setup instructions, usage examples, API reference and contribution guidelines.

Compiler and ksp plugin generates and validates service providers, utilizing annotations for streamlined integration. Accessible through mavenCentral, supports both compiler and ksp integration methods.

Automates `println` debugging by generating code to log method inputs and execution time, simplifying debugging tasks. Allows configuration of annotation class and logger method.

Lightweight runtime library and compiler plugin supports structured RAII for managing memory lifetime, reducing errors, resource leaks, and double-frees with error handling capabilities.

Enables behavior-driven development by automatically discovering test steps and executing them as separate jUnit tests. Utilizes a compiler plugin to modify test specifications, supports scenarios with placeholders, multiple scenarios per spec, and example-based scenarios.

Generates compile-time constant names for declarations with zero runtime overhead. Offers full symbol coverage and IDE-friendly generated code with immediate visibility and navigation support.

Compiler plugin adding runtime and compile-time checks: integer overflow and precision validation, collection destructuring size enforcement, and @Memoize function-result caching optimized for 0–3 args.

Enhances code by automatically applying the `@JvmStatic` annotation to all functions and properties within objects and companion objects, simplifying interoperability and static member access.

Compile-time plugin replacing annotated parameters with precise code-location strings, improving stack-trace readability and allowing customizable templates using placeholders like file, class, method, line.

Template for creating compiler plugins, enabling custom transformations and extensions. Caution advised due to complexity and potential impact on code behavior.

Compiler plugin validates the length of string properties using annotations for minimum and maximum length constraints, throwing exceptions when conditions aren't met.

Enables multiple setters for properties, resolved by argument type and invoked via standard property assignment; ideal for builders/DSLs, with inheritance-aware resolution and IDE diagnostics.

Toolkit simplifying compiler-internals workflows: utilities and abstractions to transform source into FIR and IR, enabling fast compiler-extension experiments, in-depth code analysis, and optimization prototyping.

Finite-state machine DSL for explicit state graphs with exhaustive state types, event payloads for constructing states, observable reactive state stream, deterministic non-reentrant dispatch, and Mermaid export.

Generates complete type metadata at compile time—including generics, star projections, nullability, annotations, fields and inheritance—injecting TypeInfo/FullTypeInfo for zero-reflection runtime type inspection and access.

Enforces explicit opt-in for global mutable state via RequiresGlobalState annotation; detects top-level and singleton mutables, offers configurable blacklist and Gradle integration.

Fake-data generator for tests that builds realistic object graphs with scoped overrides, deterministic seeds, nested targeting, collection/map handling, null/default control, and extensible add-ons.

Decomposes Compose presenters, eliminating callback and event plumbing by generating compile-time routing between parent and child events/effects, enabling clean, callback-free fused sub-presenters.

Compiler plugin generates builder classes for data classes, allowing property manipulation similar to a map and constructing new instances. Supports reflection for third-party library integration.

Compile-time replacement of default function argument expressions, enabling type-safe, zero-runtime-cost retrieval for displaying defaults in CLI help, configurations, and generated documentation.

Generates an interactive gallery of UI components from story files via a Gradle plugin, enabling isolated component development, preview app generation, and compiler/runtime integration.

Instruments classes at compile time to automatically track and visualize Compose State, Flows and function actions; adds diagram-style variable captures, optional stack traces, and pluggable loggers.