I'm wondering, is it worth splitting the project in 3 big gradle modules, that depend on another. Let's say

:A -> :B -> :C

. I know it's not ideal, but I don't want to burden my team on a time constrained project. It brings some challenges, that we're not used to. Is it still worth doing, or should I simply keep it a monolith? I'm guessing it would be better for the future, to at least same some basic module structure, so it could potentially be refactored a bit easier, if needed.

tasks.register("test") {
    dependsOn("desktopTest")
}

Result:

tasks.replace("test").dependsOn("desktopTest")

Result shown below, can someone help me figure out wtf happens here because I am very stumped thanks

Hi there! I'm developing a library and recently I've upgraded: Kotlin from 1.6.10 to

1.9.20

, AGP from 7.2.1 to

7.4.2

and Gradle from 7.6.1 to

8.4

. After publishing the library version with the updates, a client reported that he can no longer build using the library due to:

e: C:/.../.gradle/caches/transforms-3/c84840751d0bf885b57987b97ba24946/transformed/jetified-kotlin-stdlib-1.9.20.jar!/META-INF/kotlin-stdlib-jdk7.kotlin_module: Module was compiled with an incompatible version of Kotlin. The binary version of its metadata is 1.9.0, expected version is 1.7.1.

even after deleting all caches. I have multiple android-only and multiplatform modules that are published, none has explicit declaration of kotlin-stdlib and I'm declaring: Android-only modules `build.gradle`:

android {
    compileOptions {
        targetCompatibility JavaVersion.VERSION_1_8
        sourceCompatibility JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        languageVersion = '1.7'
        apiVersion = '1.7'
        jvmTarget = "1.8"
    }
}

Multiplaform modules `build.gradle.kts`:

kotlin {
    androidTarget {
        compilations.all {
            kotlinOptions {
                languageVersion = "1.7"
                apiVersion = "1.7"
                jvmTarget = "1.8"
            }
        }
    }

    sourceSets {
        all {
            languageSettings {
                languageVersion = "1.7"
                apiVersion = "1.7"
            }
        }
    }
}

Does any one know what could be causing this? And am I missing something to keep the library compatible with Kotlin 1.7?

what's the difference between

tasks.withType<KotlinCompile> {
  kotlinOptions {
    freeCompilerArgs = listOf("-Xjsr305=strict", "-Xallow-any-scripts-in-source-roots")
  }
}

and

kotlin {
  compilerOptions {
    freeCompilerArgs.add("-Xjsr305=strict")
    freeCompilerArgs.add("-Xallow-any-scripts-in-source-roots")
  }
}

or to be more precise why the latter one does not work ?:)

How can I get a hold on gradle tasks from a

build.gradle.kts

file inside a module (called

logic

)? This code returns

null

for both tasks even though I can find them in the GUI of android studio

val compileDebugKotlinAndroidTask = tasks.findByPath(":logic:compileDebugKotlinAndroid")
val kspCommonMainKotlinMetadataTask = tasks.findByPath(":logic:kspCommonMainKotlinMetadata")
println("compileDebugKotlinAndroidTask exists: $compileDebugKotlinAndroidTask")
println("kspCommonMainKotlinMetadataTask exists: $kspCommonMainKotlinMetadataTask")
compileDebugKotlinAndroidTask?.dependsOn(kspCommonMainKotlinMetadataTask)

...

compileDebugKotlinAndroidTask exists: null
kspCommonMainKotlinMetadataTask exists: null

I am trying to upgrade project from java 17 to java 21. Gradle version is 8.4. I have done the same on another project fra 17 to 21 and gradle version was also 8.4. But in this project I got this error:

FAILURE: Build failed with an exception.

* What went wrong:
Could not determine the dependencies of task ':compileKotlin'.
> Unknown Kotlin JVM target: 21

kotlin {
    jvmToolchain {
        languageVersion.set(JavaLanguageVersion.of(21))
    }
}

Anyone know how I can solve this issues?

Been fighting a bit with this: https://github.com/Kotlin/kotlinx.serialization/issues/2509 That got me thinking.. "Kotlin [in principle] is a programming language that makes coding concise, cross-platform, and fun." So why on earth does it still depend on gradle and extend that mess? I imagine creating a new kind of package manager is a trivial matter compared to, say, creating the kotlin compiler(s). The switching from groovy to kts seems to be mainly for syntactical reasons - in the end it is still as complex.

I recently learned about

org.jetbrains.kotlin:kotlin-gradle-plugin-api

artifact. Does it have dedicated documentation page somewhere where one can learn more about it? Does

-api

come with extra stability? Should I aim to migrate my Gradle plugins to call only classes from

-api

(meaning it's worth reporting issues if some apis don't seem available?)

👋 While experimenting with gradle-profiler, i noticed the build with jetifier enabled builds fast as compared to build with jetifier disabled. It ran 6 warm-up and 10 measurement build in both scenarios on "app:assembleDebug" task / scenario. Only difference i could find after comparing both scans, the build performing better (jetified one) uses transformed

jetified-kotlin-reflect-1.8.22.jar

as an input to kapt tasks as compared to other. Any thoughts? Ideally - build with jetifier disabled should perform better.

I register a custom task in root-level build.gradle.kts:

tasks.register<ExampleTask>("example")

abstract class ExampleTask : DefaultTask() {
    @TaskAction
    fun initialize() {
        println("Hello World")
    }
}

But when I run it

./gradlew example

I got:

Could not create task :example
    Could not create task of type ExampleTask
        Class Build_gradle.ExampleTask is a non-static inner class.

What do I miss? Thanks

Are there any tools or github actions that diff and display the dependency tree changes between commits? For instance when a dependency is upgraded, I'd like to see all of the transitive dependencies that are changing.

I'm trying to port a snippet to make natives load on android: https://github.com/bytedeco/javacv/issues/1117#issuecomment-982336622 However, since this is a multiplatform project, I'm having trouble with

val javacpp by configurations.creating

not being a valid configuration in the androidMain sourceset dependencies. How would I solve this?

Hello everyone! Is it possible somehow to have access to a function defined in the

build-logic

(included build) inside

app/build.gradle.kts

in the

plugins { }

block? I have function that looks like

fun isCI() = System.getenv("GITLAB_CI").toBoolean()

And I can use it in the

app/build.gradle.kts

everywhere except

plugins

block where I get “Unresolved reference” error

plugins {
    alias(libs.plugins...) apply isCI()
}

Hey all. I'm currently having some issues trying to apply a gradle plugin written in Groovy from my kts gradle script (Note: I do not have the ability to tweak the groovy code). Basically it seems like the groovy plugin is configured to need to see a particular method on the root project which it tries to call. So I basically get errors like: Could not find method foo() for arguments [] on root project 'my_root_project_name' of type org.gradle.api.Project I've tried defining my own function like "fun foo() ..." various places in my kts script, but no matter what I do, Groovy can't find it. Does anyone have a workaround for issues like this?

How does the new amber project to reduce complexity of the KGP plugin align with the removal of the very easy to use kotlin-js plugin, from a user perspective?

Edit3: I was just complicating everything. Java source sets are registered through the usual Java extension, so

java {
  sourceSets {
    main {
      java.srcDir("src/jvmMain/gen")
    }
  }
}

Edit2: not really working in case of Java sources sad panda Edit: I can answer myself

kotlin {
  sourceSets {
    jvmMain {
      kotlin {
        srcDir("src/jvmMain/gen")
      }
    }
  }
}

Maybe dumb question, but how do I add a `gen`erated source folder, which will be ignored but part of the classpath, under

src/jvmMain

? The project is multiplatform.

Is

withWasm

in

applyDefaultHierarchyTemplate

specifically for

wasmJs

?

Hello, can anyone explain me what exactly "Fingerprinting inputs" does (when viewing timeline in build scan)? Why can this take minutes even with 100% cache hits? It is significantly reducing the usefulness of build cache in our cases. Thanks

Hello everyone. Does anyone know a way (or plugin) to output a gradle task dependency graph? For example, I want to run a task and check which subtasks it depends on and in which order they’ll run.

set the channel topic: This channel is for Kotlin specific Gradle questions. For general Gradle questions, join the Gradle Community Slack → https://gradle.org/slack-invite

Does specifying:

android {
    ...
    
    defaultConfig {
        ...
        resourceConfiguration += listOf("en", "hdpi")
    }
}

Will also help improve unit test compile speed?

Been sittin' on this, and it's probably a bad move to say it now, but I don't myself feel good about busting people on the kotlin slack and in the gradle channel for asking for help with a gradle issue that is not obviously relevant to a kotlin build. Maybe I'm just too liberal, or maybe I don't understand the subtle distinction, or maybe I just don't see the flood of non-kotlin gradle questions here. Seems to me that anyone using the kotlin DSL in gradle is, ipso facto, a kotlin user and a gradle user. Not tryna start a fight. Just throwing out a viewpoint.

Hello! Hope this is the right channel to ask. I have a question: does the internal keyword play role in compilation avoidance in Kotlin? There is a new approach to incremental compilation in Kotlin, which improved compilation avoidance for ABI-compatible changes. https://blog.jetbrains.com/kotlin/2022/07/a-new-approach-to-incremental-compilation-in-kotlin 1 I wonder if the

internal

keyword plays a role in this. Should classes and methods that are not intended to be used outside a module be marked with the internal visibility so that changes to their signature do not cause dependent modules to be recompiled?

What's the best way to track down the cause of:

> Task :integration-tests:ksp:kspTestKotlinWasmJs FAILED
w: duplicate library name: kotlin
e: warnings found and -Werror specified

Hello guys, I am facing an issue when creating a custom task that will be registered in each module's

build.gradle.kts

file. I need

maven-publish

plugin for that. Here is how the task looks

abstract class MyTask : DefaultTask() {
    @get:Input
    abstract val moduleName: Property<String>

    @get:Input
    abstract val moduleArtifactId: Property<String>

    @get:Input
    abstract val repositoryUrl: Property<String>

    @TaskAction
    fun execute() {

        print("hello from my task, my name is ${moduleName.get()}, ${moduleArtifactId.get()}, ${repositoryUrl.get()}") //${name.get()}")
        project.publishing {
            publications {
                create<MavenPublication>("release") {
                    groupId = project.properties["groupId"] as String
                    version = project.properties["version"] as String
                    artifactId = moduleArtifactId.get()
                    project.afterEvaluate {
                        from(components["release"])
                    }
                    artifact("$buildDir/outputs/aar/$artifactId-release.aar") {
                        classifier = "release"
                    }
                }
            }
            repositories {
                maven {
                    this.name = moduleName.get()
                    this.url = uri(repositoryUrl.get())

                    credentials {
                        username = "my-user-name"
                        password = "my-password"
                    }
                }
            }
        }
    }
}

and I register it in

build.gradle.kts

in the following manner:

tasks.register<MyTask>("mytask") {
    moduleName.set("module's name")
    moduleArtifactId.set("artifact's id")
    repositoryUrl.set("remote repo's url")
}

Error I am getting is:

* What went wrong:
A problem occurred configuring project ':sdk:modulename'.
> Could not create task ':sdk:modulename:mytask'.
   > Could not create task of type 'MyTask'.
      > Class Build_gradle.MyTask is a non-static inner class.

I need a task for this since I want the exact same logic for all the modules. I just change some of things dynamically, like

url

and

artifactId

Is there any way to apply a certain plugin only for tests?

I'm applying KSP to a convention plugin that I'm using on multiple modules, but I want to make some configuration to the

KspConfiguration

. I somehow don't seem to be able to resolve that in my plugin, where could I be going wrong?

class ExamplePlugin: Plugin<Project> {

    override fun apply(target: Project) {
        with(target) {
            pluginManager.apply("com.google.devtools.ksp")

            // KspExtension doesn't resolve
            extensions.configure<KspExtension> {}

            // ksp bloc doesnt resolve
            ksp {

            }
        }
    }

Does the Kotlin Gradle Plugin impact the container architecture (in C4 Model terms, i.e. the runtime process architecture) of how Java sources are compiled by Gradle? I know the KGP adds a single

KotlinCompileDaemon

process to the mix. Does that exclusively handle the compilation of Kotlin sources, or are

compileJava

tasks executed by that as well (instead of the usual Gradle Daemon/Worker processes)? I'm trying to understand whether the standard Gradle suggestions and features for optimizing Java compilation, such as forking `JavaCompile` tasks, and the new persistent Java compiler daemon feature, apply any differently when the Kotlin Gradle Plugin is used. Just as background, I work primarily on a sizable project that mixes Java and Kotlin, and optimizing build times is a constant challenge. I currently apply the KGP to all my Gradle subprojects via a convention plugin, regardless of whether they contain only Java, only Kotlin, or a mix of both.

How can I fetch the Kotlin Project Extension? I'm trying to fix a bug in Dokkatoo https://github.com/adamko-dev/dokkatoo/issues/123 Given a multi-module Gradle project

.
└── foo-project/
    ├── submodule1 (Kotlin JVM)
    └── submodule2 (Kotlin JVM)

When I try and get KotlinProjectExtension I get an exception

val ke = project.extensions.findByType<org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension>()
// Type org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension not present

I find I need to have

kotlin("jvm") version "1.8.22" apply false

on the root project, otherwise Dokkatoo can't fetch the Kotlin

org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension

in the subprojects, even though they have applied the Kotlin JVM plugin. I tried falling back to fetching

org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension

, but that also fails with the same error, "Type org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension not present" If I debug print the available extensions, I can see that KotlinJvmProjectExtension is present

logger.warn("extensions: ${project.extensions.extensionsSchema.elements.joinToString { "${it.name} ${it.publicType}" }}")
// extensions: kotlin org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension (...)