Browse Kotlin Multiplatform libraries

Generates redacted `toString()` implementations for classes, allowing selective property redaction via a `@Redacted` annotation. Supports custom annotations and replacement strings, enabling flexible redaction configurations.

Meta-programming library enhances the compiler, enabling development of plugins, source transformations, linters, type search engines, and automatic code refactoring. Supports writing tests for plugins and quotes.

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.

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 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.

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.

Instruments @Composable functions with lightweight tracking to monitor recomposition rates against per-composable budgets, detect violations, and report via IDE performance cockpit, CLI, and logs.

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.

Enhances debugging by tracking application state changes and enabling state reversion during execution. Utilizes Flipper integration for seamless back-in-time debugging.

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.

Facilitates determination and enforcement of pure and readonly functions through compiler plugin annotations, ensuring functions adhere to strict immutability rules and enhancing code reliability.

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.

Enables easy creation of RPC methods with pluggable client, server, and serialization implementations. Offers flexibility through `expect/actual` modifiers, Ktor plugins, and comprehensive error handling. Supports advanced features like scopes, response/request headers, and microservices.

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.

Ensures code runs under specified conditions using annotations to define parameter requirements, supports combining predefined annotations and allows defining custom conditions. Currently a work in progress.

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.

Automatically generates mutable, snapshot-backed classes from immutable state definitions for Compose UIs, enabling observable, optimized primitive state, two-way conversion, bulk updates, and serialization-friendly specs.

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

Local-installable instrumentation toolkit that visually highlights UI recompositions with a lightweight pulse, using compile-time injection, Gradle integration, and opt-out annotations for selective scopes.

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.

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.

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.