Kraft

Every Kotlin codebase has that file. Forty lines of id = id, name = name, email = email that nobody wanted to write and nobody wants to review. Kraft deletes it:

- fun User.toUserDto(): UserDto = UserDto(
-     id = id,
-     name = name,
-     email = email,
- )
+ @MapConfig(source = User::class, target = UserDto::class)
+ object UserMapper

val dto = user.toUserDto() // generated at compile time

That's the whole mapper. Kraft is a KSP processor that generates type-safe extension functions between your data classes — plain, readable Kotlin you can inspect in build/generated. No reflection, no runtime library, nothing to ship.

• Breaks at build time, not in production — rename a property and the generated mapper stops compiling right there, instead of passing null around at runtime.
• Zero runtime cost — the generated code is exactly what you'd have written by hand, minus the writing.
• Multiplatform from the start — annotations live in commonMain; JVM, Android, iOS, JS, and WasmJs all work.
• Escape hatches everywhere — renames, ignores, custom converters, enum tables: when your models disagree, you override one property, not the whole mapper.

• Automatic property matching — same-name properties mapped without configuration
• Field renaming — @MapField or @FieldMapping for cross-name mapping
• Nested objects — auto-detected when types differ, including renamed properties
• Collections — List<T> and Set<T> with nested element mapping
• Enum mapping — @MapEnum with auto-matching and custom entry pairs
• Reverse mapping — @MapReverse generates the inverse mapper automatically

• Custom converters — @MapUsing for property-source or whole-source transformations
• Global converters — @KraftConverter on a top-level extension is auto-discovered across the module and the classpath, with @OptIn markers propagated onto the generated mapper
• Ignore rules — @MapIgnore and @MapIgnoreField with directional control
• Configuration objects — @MapConfig for mapping without modifying data classes
• Layer-aware aliases — register Dto / Domain / Entity sides via Gradle to emit short .toDomain() / .toEntity() extensions alongside the verbose mappers

• Kotlin Multiplatform — annotations work on JVM, iOS, JS, and WasmJs
• Plugin SPI — implement MapperGeneratorProvider to plug in your own code generator

• Kotlin 2.2+ (built and tested with Kotlin 2.2.21)
• KSP 2.3.3 (use a KSP version matching your Kotlin version)
• JDK 17+ build toolchain — the processor runs at compile time only

Kraft runs entirely at build time; the generated mappers are plain Kotlin and the annotations target JVM 1.8, so legacy apps on older runtimes are supported — see Compatibility and legacy projects.

Kraft is published to Maven Central under the com.blu3berry.kraft group (latest version shown in the badge above). Make sure mavenCentral() is in your repositories { } block, then add the dependencies below — replace <version> with the current release.

// build.gradle.kts
plugins {
    id("com.google.devtools.ksp") version "<ksp-version>"
}

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("com.blu3berry.kraft:kraft-annotations:<version>")
        }
    }
}

dependencies {
    add("kspCommonMainMetadata", "com.blu3berry.kraft:kraft-ksp:<version>")
}

// build.gradle.kts
plugins {
    id("com.google.devtools.ksp") version "<ksp-version>"
}

dependencies {
    implementation("com.blu3berry.kraft:kraft-annotations:<version>")
    ksp("com.blu3berry.kraft:kraft-ksp:<version>")
}

• Getting Started
• User Guide
• Architecture & SPI
• AI Integration
• Contributing

Copyright Kraft Contributors

Licensed under the Apache License, Version 2.0

See LICENSE for the full text.