There is so much great Gradle support here that I wanted to make sure everyone knows that we are currently accepting nominations for membership into the Gradle Fellowship program. All nominations are going onto the short list for us to consider, the Gradle Build Tool Team and current Gradle Fellows will look at all entries. Please give your input here.

Hey all, I have colleagues who don't use IntelliJ to write Kotlin. They would like some kind of way to run sandbox code like

.kts

files or `repl`'s. Is there a way I can make a custom Gradle task in our

build.gradle.kts

that launches a

.kts

script that has our project code and library modules on the classpath for them? Thank you!

Maybe another noob question here, but would it be possible for me to create a custom gradle plugin that does the following: • apply multiplatform, compose and publishing plugins • set some sensible defaults • add some basic dependencies The reason I want this is that I want to have one starting point for all my projects with all the versions correctly set. I then only want to apply this plugin to get started. Would the preferred way be a real Gradle plugin, or would it be possible in a precompiled script plugin?

Hi everyone! I was looking for a way to be able to change KDocs at compile-time such that changes appear in the sources.jar as well as potentially a javadoc.jar or HTML Dokka site. Existing solutions only worked for the latter and since there exists no such thing as a kdoc.jar, changed documentation doesn't always (correctly) show up when a user is working with your open source library. Introducing my KDoc / JavaDoc Preprocessor Gradle Plugin! This plugin acts as a preprocessor on your sources, allowing you to create new sources from your own with modified KDoc/JavaDocs. The plugin contains a couple of default processors, but is also extensible to include your own! Examples include: •

@include

tag to include other comments into your KDoc / JavaDoc, see @include Processor (

INCLUDE_DOC_PROCESSOR

) •

@sample

/

@sampleNoComments

tag to include code samples into your KDoc / JavaDoc (

SAMPLE_DOC_PROCESSOR

) • A processor that removes all KDoc / JavaDoc comments (

NO_DOC_PROCESSOR

) • A processor that adds a

/** TODO */

comment wherever there is no KDoc / JavaDoc comment (

TODO_DOC_PROCESSOR

) • A processor that makes all KDoc / JavaDoc comments uppercase (try and make this for fun!) • The sky is the limit :) Note that this first release is still an early Alpha, but I'm welcome to feedback, bugs, your own processors and whatnot 🙂

I've written a short article how to use version catalog with toml file in your Gradle project together with the version catalog update plugin. https://link.medium.com/Fw6NPeddMwb

Hello! Does anybody had success with integrating R8 with non Android JVM project (shrinking, obfuscating, optimization)? Any examples of build.gradle.kts?

The second article in this series is also available now. This time regarding convention plugins. https://link.medium.com/BvomEScGOwb

I am trying to use a preview JDK in my Kotlin compiler config, but I am getting a strange error. Has anyone seen this before:

val JDK_21_PATH = "/home/user/.sdkman/candidates/java/21.ea.6-open"

tasks.withType<org.jetbrains.kotlin.gradle.tasks.UsesKotlinJavaToolchain>().configureEach {
    kotlinJavaToolchain.jdk.use(JDK_21_PATH, JavaVersion.VERSION_21)
}

Execution failed for task ':app:compileKotlin'.
> Error while evaluating property 'compilerOptions.jvmTarget' of task ':app:compileKotlin'.
   > Failed to calculate the value of property 'jvmTarget'.
      > Unknown Kotlin JVM target: 21

What is the best way or a good way to handle dependency versioning across multiple projects. Each project has its independent repo and exposes an aar, they are not modules in a single project. I am thinking of moving the common dependencies to a common project and expose them as api. The problem is that now, all projects need to depend on this common library, which is not necessarily what the business requires. Any recommendation?

FYI: there is a memory leak in

kotlin-reflect.1.8.0

leading to OOM in Kotlin Daemon (or kapt) Metaspace

I want to create a plugin that applies the shadow jar plugin and configures it, but i can’t figure out how to add shadowJar as a dependency to the plugin, I tried:

implementation("gradle.plugin.com.github.johnrengelman:shadow:7.1.2")

But i can’t reference ShadowJar class in my main plugin (binary) code Any advice?

Another more urgent question, i suddenly started getting

Execution failed for task ':compileKotlin'.
> Default Kotlin compiler classpath is empty! Task: :compileKotlin (org.jetbrains.kotlin.gradle.tasks.KotlinCompile_Decorated)

And i can’t figure out why and what it means. Can anyone help?

I still am unable to figure out how to make a convention plugin that just applies Compose....It's driving me nuts. See thread for my current code for the plugin.

This message was deleted.

I can’t get the function

takingUnaryClosure

since what gradle version is it available?

hey folks. is anyone aware of a way to register a Gradle task such that it runs in continuous mode i.e. as if

--continuous

had been passed?

Hey, I was wondering how I would add two modules into the same publication? I have a module called

api

that implements things from the module

shared

however, when I publish

api

locally then it can't find

shared

even with shadow, The error is

> Could not resolve all dependencies for configuration ':runtimeClasspath'.
   > Could not find io.github.tech:shared:0.0.1.

I have a module called

Okay, I finally got a working project with version catalogs and precompiled scripts plugins for my personal projects. There were some weird things though: • when adding the plugins in the

buildSrc

, because I needed them in the precompiled scripts, I needed to add them to the

implementation

block. However this resulted in the fact that they were on the classpath in the other projects as well and there I only needed to apply them when needed. This felt a bit weird, but writing it out it makes sense I think.... but it is not something I did before. Normally I would define the plugins in the root

build.gradle.kts

with the

apply

set to

false

• IntelliJ IDE autocomplete and code-highlighting is terribly broken in the plugins. The only cure was restarting the IDE a lot of times. This made development a bit hard. I have the latest IDE. • Getting the plugins from the version-catalog in the

implementation

of the the

buildSrc

I had to do weird string interpolation and separate getting of the plugin-id and plugin-version. However, I learned a lot I think, but Gradle is still a very complicated powerful beast for me. I have the working repository here: https://github.com/avwie/kotlinx Maybe if some people have some comments on how to do it better I'd like to know.

Interesting article about Gradle at square https://developer.squareup.com/blog/stampeding-elephants/

I'm looking at the code here: https://github.com/JetBrains/kotlin/blob/master/libraries/tools/kotlin-main-kts-test/build.gradle.kts. I'm wondering how could I get the classpath of the compose compiler instead. Problem is I in the linked gradle config, they use

project

inside of that configuration function. I can't use that since the compose plugin isnt in my project. Also implementation doesn't return the same type as project, and that doesn't work. Any ideas on what I can do?

Anyone had issues before with a

ClassNotFound: GradleWorkerMain

error in gradle builds? (Note that’s GradleWorkerMain, not GradleWrapperMain which is more commonly discussed as a source of issues). This is happening only on CI build machines, and seemingly only upon reaching a test task (assemble ran fine, detekt ran fine, tests fail with that error). In my CI environment there’s a collection of different projects with different gradle versions and the build machine has a few versions of JDK installed, so I feel like there’s potential for clashes/corruption somehow creeping in, especially since deleting the gradle caches seems to make the problem go away for a little while. Not really sure where to start to diagnose what exactly is triggering it I’ve found next to no info on it in searches, everything just directs to the aforementions “GradleWrapperMain” error

Start writing your own custom Gradle plugins: https://link.medium.com/YjqoztfA5wb

Probably a stupid question. Is it possible to have different gradle sub-projects with different Kotlin version targets? I'd like A to target Kotlin 1.8 and B to target 1.7.20. A depends on B. Assume A is a server and B is a client SDK. Would I have to use composite builds?

I’ve been reading about providing multiple variants of a Gradle plugin based on the Gradle version https://docs.gradle.org/current/userguide/implementing_gradle_plugins.html#plugin-with-variants So I can publish a plugin for Gradle 7, and a variant of the same plugin for Gradle 6 - both have the same plugin ID, and Gradle will select the appropriate one dynamically, based on the receiver’s Gradle version. Instead, could I publish a Gradle plugin that has variants for Kotlin 1.8, 1.7, and 1.6? So if my plugin is applied when the Kotlin 1.7 plugin is present, Gradle will select my plugin variant that’s compatible with 1.7. The reason being is that I’m getting ClassNotFound errors with KotlinBasePlugin and KotlinProjectExtension.

When trying to bump to Kotlin 1.8.10 using Gradle 7.6, I’m seeing a build failure when the root build.gradle.kts has dependency locking enabled with:

buildscript { dependencyLocking {lockAllConfigurations} }

Is this a bug in 1.8.10? Is there some kind of migration or API change I need to handle?

Execution failed for task ':assertion-lib:compileKotlinJvm'.
> Could not resolve all files for configuration ':assertion-lib:detachedConfiguration1'.
   > Failed to transform kotlin-stdlib-jdk8-1.8.10.jar to match attributes {artifactType=classpath-entry-snapshot, org.gradle.libraryelements=jar, org.gradle.usage=java-runtime}.
      > Execution failed for ClasspathEntrySnapshotTransform: /Users/carter/.gradle/caches/modules-2/files-2.1/org.jetbrains.kotlin/kotlin-stdlib-jdk8/1.8.10/7c002ac41f547a82e81dfebd2a20577a738dbf3f/kotlin-stdlib-jdk8-1.8.10.jar.
         > 'void org.jetbrains.kotlin.incremental.storage.ExternalizersKt.saveToFile(org.jetbrains.kotlin.com.intellij.util.io.DataExternalizer, java.io.File, java.lang.Object)'
   > Failed to transform kotlin-stdlib-jdk7-1.8.10.jar to match attributes {artifactType=classpath-entry-snapshot, org.gradle.libraryelements=jar, org.gradle.usage=java-runtime}.
      > Execution failed for ClasspathEntrySnapshotTransform: /Users/carter/.gradle/caches/modules-2/files-2.1/org.jetbrains.kotlin/kotlin-stdlib-jdk7/1.8.10/cb726a23c808a850a43e7d6b9d1ba91b02fe9f05/kotlin-stdlib-jdk7-1.8.10.jar.
         > 'void org.jetbrains.kotlin.incremental.storage.ExternalizersKt.saveToFile(org.jetbrains.kotlin.com.intellij.util.io.DataExternalizer, java.io.File, java.lang.Object)'
   > Failed to transform kotlin-stdlib-1.8.10.jar to match attributes {artifactType=classpath-entry-snapshot, org.gradle.libraryelements=jar, org.gradle.usage=java-runtime}.
      > Execution failed for ClasspathEntrySnapshotTransform: /Users/carter/.gradle/caches/modules-2/files-2.1/org.jetbrains.kotlin/kotlin-stdlib/1.8.10/6d5560a229477df9406943d5feda5618e98eb64c/kotlin-stdlib-1.8.10.jar.
         > 'byte[] org.jetbrains.kotlin.incremental.storage.ExternalizersKt.toByteArray(org.jetbrains.kotlin.com.intellij.util.io.DataExternalizer, java.lang.Object)'
   > Failed to transform annotations-13.0.jar to match attributes {artifactType=classpath-entry-snapshot, org.gradle.libraryelements=jar, org.gradle.usage=java-runtime}.
      > Execution failed for ClasspathEntrySnapshotTransform: /Users/carter/.gradle/caches/modules-2/files-2.1/org.jetbrains/annotations/13.0/919f0dfe192fb4e063e7dacadee7f8bb9a2672a9/annotations-13.0.jar.
         > 'void org.jetbrains.kotlin.incremental.storage.ExternalizersKt.saveToFile(org.jetbrains.kotlin.com.intellij.util.io.DataExternalizer, java.io.File, java.lang.Object)'

Is there a reason I need to set

dependencyResolutionManagement

also in a

includeBuild

project even though I have defined them at the top level already in

settings.gradle.kts

?

I keep bombarding with n00b questions here, but I have trouble figuring it out. Suppose I have the following directories: • plugins ◦ conventions ▪︎ build.gradle.kts ▪︎ settings.gradle.kts ▪︎ src/main/kotlin/... .gradle.kts ◦ starters ▪︎ build.gradle.kts ▪︎ settings.gradle.kts ▪︎ src/main/kotlin/... .gradle.kts • settings.gradle.kts In the root

settings.gradle.kts

I have:

includeBuild('plugins/conventions')
includeBuild('plugins/starters')

How can I reference plugins defined in

conventions

in the

starters

project? They are unable to resolve and I have no clue on how to add them to the dependencyResolutionMaangement of

starters

.

Does anybody know why gradle download groovy-provider(%3F).pom every time i rebuild?

Has anyone seen this incremental compilation issue when referencing generated code in test? https://youtrack.jetbrains.com/issue/KT-56423/Test-Incremental-Compilation-fails-with-Cannot-access-class-xxx.Foo.-Check-your-module-classpath-for-missing-or-conflicting

Does anyone know where the source code for Kotlin/JS and Kotlin/Multiplatform plugins are hosted at? Are those plugins not open source? I haven't been able to locate the code for the plugins in the Kotlin source code.