A modern programming language that makes developers happier.

kotlinlang

How can we split a huge `build.gradle.kts` script into multiple short scripts that configure plugins and tasks? Do `buildSrc` can help while <https://github.com/gradle/kotlin-dsl/issues/424> and <https://github.com/gradle/kotlin-dsl/issues/427> don't get fixed?

<https://docs.gradle.org/current/userguide/plugins.html#sec:script_plugins>

Don't know your specifics, but I've found it very easy to implement Gradle Plugin interface in buildSrc and apply it via `plugins {}`. This approach really helped to properly structure the builds I've got on my hands. My build.gradle.kts files are now much leaner and utility functionality which earlier littered them is now much better looking as custom plugins in buildSrc.

buildSrc doesn't even need to be applied via `plugins {}`

I believe it does, when you're implementing a plugin that is.
You are right that one wouldn't need that for "normal" code though, like some classes or functions to call from the script.

Thank you all for suggestions.

<@U3BE1HS4W> That seems nice. It seems to be the around for those issues.

<@U0CP8EBRV> It's just a huge script with `plugins {}` block and tasks configuration. Here is the file <https://github.com/lucasvalenteds/responder/blob/main/responder-api/build.gradle.kts>.

Just in case, here is a POC for the issues linked, which I'm looking for a workaround. <https://github.com/lucasvalenteds/gradle-kotlin-dsl-scripts>

my workaround would be to just throw those in `buildSrc`, include the `kotlin-dsl` plugin in it, and wrap them in a plugin `apply`.

you can apply the plugins using `Project.apply` and add them to the `buildSrc` classpath for versioning, which imo is a little cleaner (have your versions in one spot, usages in another)

perhaps not even make them a `plugin`, it's a little overkill

just have a `fun Project.shadowJarConfiguration() { ... }` and call that

Thank you <@UCJ90MC59>. Do you mean something like this:

`buildSrc/build.gradle.kts`
```
import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

plugins {
    `kotlin-dsl`
    id("org.jetbrains.kotlin.jvm") version "1.3.11"
    id("com.github.johnrengelman.shadow") version "2.0.4"
}

repositories {
    jcenter()
}

fun Project.kotlinConfiguration() {
    tasks.withType&lt;KotlinCompile&gt; {
        kotlinOptions.jvmTarget = "1.8"
    }
}

fun Project.shadowJarConfiguration() {
    tasks.withType&lt;ShadowJar&gt; {
        baseName = rootProject.name
        version = rootProject.version.toString()
        classifier = ""
        destinationDir = rootProject.projectDir
    }
}
```

`build.gradle.kts`
```
// Leave it empty
```

no, those `fun`s go in `src/main/kotlin/&lt;pkg&gt;`

and you will need to write `build.gradle.kts` as:
```
// &lt;relevant imports, IntelliJ can add them for you&gt;
kotlinConfiguration()
shadowJarConfiguration()
```

you can see this in my project: common stuff in <https://github.com/kenzierocks/reticulated-audio-wranglin-regulator/blob/master/buildSrc/src/main/kotlin/net/octyl/common.kt>

and then apply it in script like <https://github.com/kenzierocks/reticulated-audio-wranglin-regulator/blob/master/common/build.gradle.kts#L22>