rules_kotlin

When using resource_strip_prefix in a Kotlin target, rules_kotlin ensures that resource paths are correctly resolved even when the target depends on an external Bazel module.

If a library in an external module (e.g., @nested//:library) defines resources with a specific resource_strip_prefix, the rules must correctly identify the resource path relative to that prefix, regardless of whether the external module's directory is included in .bazelignore or how the module path is prefixed in the filesystem.

In a correctly functioning setup, a resource located at nested/resourcez/resource.txt with resource_strip_prefix = "resourcez" will be correctly stripped, allowing the application to access the resource via the path resource.txt.

Call the kt_register_toolchains() macro to register the Kotlin toolchain in your Bazel workspace.

load("@rules_kotlin//kotlin:core.bzl", "kt_register_toolchains")

kt_register_toolchains()

To add a new integration test to the rules_kotlin repository, follow these steps:

1. Create a new workspace within the examples/ directory.
2. Ensure the rules_kotlin repository is named exactly rules_kotlin in your configuration.
3. If the example is incompatible with specific Bazel versions, create an exclude directory containing a file named after that Bazel version.
4. Update the list of excluded packages by running the following command:

bazel run @rules_bazel_integration_test//tools:update_deleted_packages

You can improve build performance by enabling compilation avoidance. This uses ABI jars (interface/header jars) for classpath dependencies, allowing Bazel to avoid recompiling downstream targets when changes do not affect the public API.

To enable this, set experimental_use_abi_jars = True in your define_kt_toolchain configuration.

load("//kotlin:core.bzl", "define_kt_toolchain")

define_kt_toolchain(
    name = "kotlin_toolchain",
    experimental_use_abi_jars = True,
)

To install the Jetpack Compose example app onto an Android device and launch it immediately, use the bazel mobile-install command. You must specify the target, the Android platform architecture (e.g., --android_platforms=//:arm64-v8a), and use the -- separator to pass the --launch_activity flag to the device.

bazel mobile-install //app:compose_example_app --android_platforms=//:arm64-v8a -- --launch_activity=cm.ben.android.bazel.compose.example.ui.MainActivity

To build the Jetpack Compose example application using Bazel, run the bazel build command targeting the //compose-app:compose_example_app label. This produces the deploy JAR, an unsigned APK, and a signed APK.

bazel build //compose-app:compose_example_app

KSP is supported via the kt_ksp_plugin rule. You define a processor and then apply it to a kt_jvm_library via the plugins attribute.

Configuring KSP Version

You can specify a custom KSP version distribution depending on your dependency management system.

load("@rules_kotlin//kotlin:core.bzl", "kt_ksp_plugin")
load("@rules_kotlin//kotlin:jvm.bzl", "kt_jvm_library")

kt_ksp_plugin(
    name = "moshi-kotlin-codegen",
    processor_class = "com.squareup.moshi.kotlin.codegen.ksp.JsonClassSymbolProcessorProvider",
    deps = [
        "@maven//:com_squareup_moshi_moshi",
        "@maven//:com_squareup_moshi_moshi_kotlin",
        "@maven//:com_squareup_moshi_moshi_kotlin_codegen",
    ],
)

kt_jvm_library(
    name = "lib",
    srcs = glob(["*.kt"]),
    plugins = ["//:moshi-kotlin-codegen"],
)

To customize language levels and JVM targets, define a toolchain using define_kt_toolchain in a BUILD file, then register it in your WORKSPACE file.

Supported API versions: 1.9, 2.0, 2.1, 2.2, or 2.3. Supported JVM targets: 1.8, 9 through 25.

# In <workspace>/BUILD.bazel
load("@rules_kotlin//kotlin:core.bzl", "define_kt_toolchain")

define_kt_toolchain(
    name = "kotlin_toolchain",
    api_version = KOTLIN_LANGUAGE_LEVEL,  # e.g., "1.9"
    jvm_target = JAVA_LANGUAGE_LEVEL, # e.g., "17"
    language_version = KOTLIN_LANGUAGE_LEVEL,  # e.g., "1.9"
)

# In WORKSPACE
register_toolchains("//:kotlin_toolchain")

The dependencies example contains a chain of libraries (lib1 -> lib2 -> lib3 -> lib4) supporting various language and platform combinations. Use the following commands to build specific library types:

• Java JVM: Build a regular Java library for the JVM.
• Java Android: Build a regular Java library for Android.
• Kotlin JVM: Build a regular Kotlin library for the JVM.
• Kotlin Android: Build a Kotlin library for Android (requires building both src_main and src_main_kt targets).

# Regular Java JVM library
bazel build libJava1:src_main

# Regular Java Android library
bazel build liblibAndroid1Java1:src_main

# Regular Kotlin JVM library
bazel build libKt1:src_main

# Android Kotlin library
bazel build libKtAndroid1:src_main libKtAndroid1:src_main_kt