Gradle

4 collapsed lines
distributionBase=GRADLE_USER_HOME
        
The  home of where the  unpacked  Gradle distribution should be stored 

GRADLE_USER_HOME at ~/.gradle 
PROJECT at . 
distributionPath=wrapper/dists
        
Relative  path from distributionBase where the  unpacked  Gradle distribution is stored 
zipStoreBase=GRADLE_USER_HOME
      
The  home of where the  archived  Gradle distribution should be stored 

GRADLE_USER_HOME at ~/.gradle 
PROJECT at . 
zipStorePath=wrapper/dists
      
Relative  path from zipStoreBase where the  archived  Gradle distribution is stored 
distributionUrl=https\://services.gradle.org/distributions/gradle-9.0.0-bin.zip
        
The  URL to download the  Gradle distribution from —
 gradle-version-type.zip

 version can be in the format 0.0.0 or one of:

latest
release-candidate
release-milestone
release-nightly
nightly


 type can be one of:

bin  binary only, lightweight recommended
all  binary +  source



 Gradle Docs — Distribution URL 
Version 
Type 
4 collapsed lines
networkTimeout=10000
       
The network  timeout to use during the  Gradle distribution  download, in ms 
retries=0
    
The number of  retries to attempt the  Gradle distribution  download 
retryBackOffMs=500
       
The  delay to wait between  Gradle distribution  download retries, in ms 
validateDistributionUrl=true
            
Enables the  validation of the  Gradle distribution  URL 

tasks {
    wrapper {
    
    
The  Wrapper task can be configured here 

 Gradle Docs — Wrapper Task 
        jarFile = file("gradle/wrapper/gradle-wrapper.jar")
        
    
The  wrapper directory can be configured 
        scriptFile = file("gradlew")
        
     
The  gradlew scripts can be configured 
    }
}

includeBuild("../OtherProject")

dependencies {
    implementation("me.username:other-project:1.0.0")
}

rootProject.name = "other-project"

version = "1.0.0"
group = "me.username"

include("module")

dependencies {
    implementation(project(":module"))
}

4 collapsed lines
plugins {
    `java`
    
   
Apply a  JVM language plugin
}

sourceSets { 
     
 JVM language plugins add  sourceSets which can be configured here 

 Gradle Docs — Custom Sourcet Set paths  SourcetSet 
    main {
        java.srcDirs("src/$name/java")
        
  
The  src /  main /  java directory can be configured
        resources.srcDirs("src/$name/resources")
        resources.srcDirs("src/$name/resources")
        
     
The  src /  main /  resources directory can be configured
    }
    test {
        java.srcDirs("src/$name/java")
        
  
The  src /  test /  java directory can be configured
        resources.srcDirs("src/$name/resources")
        
     
The  src /  test /  resources directory can be configured
    }
} 

4 collapsed lines
plugins {
    `java`
    
   
Apply a  JVM language plugin
}

sourceSets {
    main {
        java.srcDirs("src/java")
        resources.srcDirs("src/resources")
        
              
Move  main source set to  src
    }
    test {
        java.srcDirs()
        resources.srcDirs()
        
              
Remove  test source set directory
    }
}

tasks {
    testClasses {
        enabled = false
        
    
Disable  :testClasses task
    }
}

4 collapsed lines
plugins {
    `java`
    
   
Apply a  JVM language plugin
}

sourceSets {
    val custom by registering {}
    
                    
 sourceSets can be added 

 Gradle Docs — Defining new source sets  SourcetSet 
}

fun DependencyHandlerScope.customImplementation(it: Any) = add("customImplementation", it)
fun DependencyHandlerScope.customCompileOnly(it: Any) = add("customCompileOnly", it)
fun DependencyHandlerScope.customRuntimeOnly(it: Any) = add("customRuntimeOnly", it)
                              
Define  Dependency configuration functions per  sourceSet

dependencies {
    customImplementation("org.processing:core:4.0.0")
    
          
 Dependencies can be added per  sourceSet
}

val SourceSetContainer.custom get() = sourceSets.named("custom").get()
                          
A  sourceSet accessor can be defined

tasks {
    val customJar by registering(Jar::class) {
    
                               
A  :sourceSetJar task can be defined
        archiveClassifier = sourceSets.custom.name
        from(sourceSets.custom.output)
    }
}

layout.buildDirectory = file("build")
              
The  build directory can be customized 
 Gradle Docs — Build Directory 

allprojects {
     
Configure the  module and all its descendants at once

Recommended to only be used in the root  Project

 Gradle Docs — allprojects 
    ...
}

subprojects {
      
Configure all descendant  modules at once 

 Gradle Docs — subprojects 
    ...
}

pluginManagement {
    includeBuild("build-logic")
}

plugins {
    `kotlin-dsl`
    
      
Apply the  Kotlin DSL plugin

Allows to write  Convention plugins
using the  Gradle Kotlin DSL

 Gradle Docs — Kotlin DSL 
}

repositories {
    gradlePluginPortal()
    
         
Required to download the  Kotlin Standard Library  

 Kotlin Docs — kotlin-stdlib 
}

...

plugins {
    id("shared-config")
    
 
Apply the  Convention plugin by name
}

plugins {
    java
    
  
Apply the  Java plugin 

 Gradle Docs — Java Plugin 
}

java { 
java { 
  
The Java Plugin can be configured here 

 Gradle Docs — Java Plugin Extension 
    toolchain { 
    toolchain { 
    
     
Specifies the JDK/JRE used by this project

This replaces legacy sourceCompatibility and targetCompatibility 

 Gradle Docs — JVM Toolchain 
Java Toolchain Spec 
        languageVersion = JavaLanguageVersion.of(26)
        vendor = null
    } 

    withJavadocJar()
    
       
Adds the  :javadocJar task 

 Gradle Docs —  Java Project · Packaging and publishing 
    withSourcesJar()
    
       
Adds the  :sourcesJar task 

 Gradle Docs — Java Project · Packaging and publishing 
} 

sourceSets { 
sourceSets { 
     
The Java plugin adds  sourceSets which can be configured here

 Gradle Docs — Custom Sourcet Set paths  SourcetSet 
    //#collapse
    main { 
    main { 
        java {
            setSrcDirs(listOf("src/main/java"))
            
                          
The  src /  main /  java directory can be configured
        }

        resources {
            setSrcDirs(listOf("src/main/resources"))
            
                            
The  src /  main /  resources directory can be configured
        }
    } 

    test { 
    test { 
        java {
            setSrcDirs(listOf("src/test/java"))
            
                          
The  src /  test /  java directory can be configured
        }

        resources {
            setSrcDirs(listOf("src/test/resources"))
            
                            
The  src /  test /  resources directory can be configured
        }
    } 
    //#endcollapse
    //#collapse
    create("sourceSetName") {

    }
    //#endcollapse
} 

tasks { 
tasks { 

    jar { 
    jar { 
    
  
The  :jar task can be configured

if present,  :javadocJar and   :sourcesJar can also be configured

 Gradle Docs — Jar Task 
        archiveBaseName.set(project.name)
        archiveVersion.set("${project.version}")
        archiveExtension.set("jar")
        archiveAppendix.set("")
        archiveClassifier.set("")
        
         
The default jar naming format is:

[baseName]-[appendix]-[version]-[classifier].[extension]

 Gradle Docs — Archive File Name 
        archiveFileName.set("executable.jar")
        
        
Alternatively, the jar can be renamed altogether 

 Gradle Docs — Archive File Name 

        manifest { 
        manifest { 
        
    
The jar's manifest file can be configured here

The manifest file is located at META-INF/MANIFEST.MF 
Alternatively, the manifest file could be copied from  resources

 Gradle Docs — Modifying the JAR manifest 
Manifest 
            attributes["Main-Class"] = "me.self.Main"
            attributes["Implementation-Title"] = "Cool Project Name"
            ... //! blur
        } 
    } 

    withType<JavaCompile> { 
    withType<JavaCompile> { 
    
               
Both  JavaCompile tasks of  main and  test can be configured at once 

 Gradle Docs — Java Compile 
        options.apply { 
        options.apply { 
        
    
Compile Options can be configured here 

 Gradle Docs — Compile Options  

 Oracle Docs — Java Compiler Options 
            release = java.toolchain.languageVersion.get().asInt()
            compilerArgs = listOf()
            debugOptions.debugLevel = "source,lines,vars"
            encoding = null
            isDebug = true
            isDeprecation = false
            isFailOnError = true
            isIncremental = true
            isFork = false
        } 
    } 

    withType<ProcessResources> { 
    withType<ProcessResources> { 
    
                 
Both  ProcessResources tasks of  main and  test can be configured at once

Run  :clean when editing this task to ensure up to date output

 Gradle Docs — Process Resources 
Copy 
        includeEmptyDirs = true

        rename("manifest.txt", "META-INF/MANIFEST.MF")
        
   
files can be renamed 
        exclude("transient")
        
    
files can be excluded 
        filesMatching("config.yml") { 
        filesMatching("config.yml") { 
            expand( 
            expand( 
            
   
files can have template properties ${...} 

 Gradle Docs — Expand 
                mapOf(
                    "version" to project.version,
                    "name" to project.name,
                    ... //! blur
                )
            ) 
        } 

        ... //! blur
    } 

    javadoc { 
    javadoc { 
    
The  :javadoc task can be configured 

 Gradle Docs — Javadoc Task  

 Jetbrains Docs — Javadocs 
        options { 
        options { 
        
    
Javadoc options can be configured here 

 Gradle Docs — Minimal Javadoc Options  

 Oracle Docs — Javadoc Options 
            windowTitle = null
            header = null
            locale = null
            encoding = null
            memberLevel = JavadocMemberLevel.PROTECTED
            outputLevel = JavadocOutputLevel.QUIET
            jFlags = listOf()

            doclet = null
            docletpath = null
            
     
A custom docklet engine can be used

The default is StandardDoclet 

 Oracle Docs — Docklet API 
        } 
    } 

    test { 
    test { 
    
  
The  :test task's test framework can be configured here 

 Gradle Docs — Testing in Java & JVM projects  Test Task 
        useJUnitPlatform()
        
        
Use the  JUnit test framework recommended 

useJUnit() is legacy for ≤v4
        useTestNG()
        
     
Alternatively, you can use the  TestNG test framework 
    } 
} 

//#collapse
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
//#endcollapse

plugins { 
plugins { 
    kotlin("jvm") version "2.0.0"
    
   
The Gradle Kotlin DSL has built-in  Kotlin support

kotlin(...) is a shortcut for id('org.jetbrains.kotlin.$module') 

 Kotlin Docs — Gradle Plugin 
releases 
} 

repositories {
    mavenCentral()
    
      
Required to download the  Kotlin Standard Library  

 Kotlin Docs — kotlin-stdlib 
}

kotlin { 
kotlin { 
    jvmToolchain(26)
    
      
Setting a toolchain via the kotlin {} extension updates the toolchain for java {} as well 

 Kotlin Docs — Java Toolchain Support 
    compilerOptions {
    
        
Kotlin compiler options can be configured here 

 Kotlin Docs — Compiler options in KGP 
Kotlin compiler options 
        freeCompilerArgs.addAll(listOf())
    }
} 

sourceSets { 
sourceSets { 
     
The Kotlin plugin adds  sourceSets which can be configured here

 Kotlin Docs — Kotlin and Java sources  SourcetSet 
    //#collapse
    main { 
    main { 
        kotlin {
            setSrcDirs(listOf("src/main/kotlin"))
            
                           
The  src /  main /  kotlin directory can be configured
        }

        resources {
            setSrcDirs(listOf("src/main/resources"))
            
                            
The  src /  main /  resources directory can be configured
        }
    } 

    test { 
    test { 
        kotlin {
            setSrcDirs(listOf("src/test/kotlin"))
            
                           
The  src /  test /  kotlin directory can be configured
        }

        resources {
            setSrcDirs(listOf("src/test/resources"))
            
                            
The  src /  test /  resources directory can be configured
        }
    } 
    //#endcollapse
} 

tasks { 
tasks { 

    withType<KotlinCompile> {
    
                
Both  KotlinCompile tasks of  main and  test can be configured at once

Requires import

 Gradle Docs — Compiler options in KGP 
        compilerOptions {
            freeCompilerArgs.addAll(listOf())
        }
    }

} 

plugins {
    `java`
    
   
Apply a  JVM language plugin
}

tasks {
    jar {
        manifest {
            attributes["Main-Class"] = "me.username.Main"
            
                 
Reference your  Main class here 
        }
    }
}

plugins {
    `java`
    
   
Apply a  JVM language plugin
    id("org.panteleyev.jpackageplugin") version "2.0.0"
    
                       
Apply the  JPackage plugin
}

repositories {
    gradlePluginPortal()
    
         
Required to download  Plugins
}

version = "0.0.0"
    
A version is required by  JPackage

tasks {
    jpackage {
    
    
Configure  JPackage here 

 GitHub — JPackage Gradle Plugin 
        dependsOn("build")

        input = layout.buildDirectory.dir("libs")
        destination = layout.buildDirectory.dir("dist")

        mainClass = "me.username.Main"
        mainJar = jar.get().archiveFileName.get()

        type = ImageType.APP_IMAGE

        winConsole = true
    }
}

plugins {
    `java`
    
   
Apply a  JVM language plugin
    id("org.graalvm.buildtools.native") version "1.1.0"
    
 
Apply the  GraalVM Native plugin
}

graalvmNative {
       
 GraalVM Native is configured here 

 GraalVM Docs — Native Gradle plugin 

    binaries {
        named("main") {
            mainClass = "me.username.Main"
            
     
Reference your  Main class here 
        }
    }
}

plugins {
    `java`
    
   
Apply a  JVM language plugin
    `maven-publish`
    
        
Apply the  Maven publish plugin 

 Gradle Docs — Maven Publish Plugin 
    `signing`
    
     
x
}

publishing { 
publishing { 
     
The  Maven publish plugin can be configured here
    publications { 
    publications { 
    
      
 Maven publications are listed here
        register<MavenPublication>("maven") { 
        register<MavenPublication>("maven") { 
        
    
Creating a  Maven publication will generate  tasks from its given name for each repository  

 Gradle Docs — Maven Publication 
            groupId = "${project.group}"
            artifactId = "${project.name}"
            version = "${project.version}"
            
    
The  Maven coordinates group:artifact:version can be overriden 

            pom { 
            pom { 
            
  
The  pom.xml can be configured here 

 Gradle Docs — Maven Pom  

 Maven Docs — POM Reference 
                name = project.name
                description = project.description
                url = "https://www.username.me/project"
                packaging = "jar"
                inceptionYear = "2026"

                licenses {
                    license {
                        name = "MIT"
                        url = "https://opensource.org/license/MIT"
                    }
                }
                developers {
                    developer {
                        id = "username"
                        name = "Full Name"
                        email = "contact@username.me"
                        url = "https://username.me"
                        organization = "Organization"
                        organizationUrl = "https://organization.com"
                        roles = listOf("developer")
                        timezone = "UTC"
                        properties = mapOf()
                    }
                }
                contributors {
                    contributor {
                        name = "Full Name"
                        email = "contact@contributor.me"
                        url = "https://username.me"
                        organization = "Organization"
                        organizationUrl = "https://organization.com"
                        roles = listOf("developer")
                        timezone = "UTC"
                        properties = mapOf()
                    }
                }
                organization {
                    name = "Organization"
                    url = "https://organization.com"
                }
                scm { // source control management
                    connection = "scm:git:https://github.com/OWNER/REPO.git"
                    developerConnection = "scm:git:ssh://github.com/OWNER/REPO.git"
                    url = "https://github.com/OWNER/REPO"
                    tag = "v${version}"
                }
                issueManagement {
                    system = "GitHub"
                    url = "https://github.com/OWNER/REPO/issues"
                }
                ciManagement {
                    system = "GitHub Actions"
                    url = "https://github.com/OWNER/REPO/actions"
                }
                distributionManagement {
                    downloadUrl = "https://github.com/OWNER/REPO/releases"
                    relocation {
                    
     
 Maven publication can indicate it was moved 
                        groupId = "${project.group}".replaceFirst("me.", "io.")
                        artifactId = "${project.name}"
                        version = "${project.version}"
                        message = "Artifact moved to $groupId:$artifactId"
                    }
                }

                mailingLists {
                    mailingList {
                        name = "Development"
                        subscribe = "dev-subscribe@username.me"
                        unsubscribe = "dev-unsubscribe@username.me"
                        post = "dev@username.me"
                        archive = "https://username.me/archive/dev"
                        otherArchives = setOf()
                    }
                }

                properties = mapOf()
                
     
 properties can be defined  

 Maven Docs — POM · Properties 

                withXml {
                
    
The  XML can be configured 
                    with(asNode()) { //! blur
                        appendNode("name", mapOf("key" to "value"), "value") //! blur
                            .appendNode("child-name", mapOf("key" to "value"), "child-value")
                    } //! blur
                }
            } 

            from(components["java"])
            
  
Publish your  Gradle project as a  Maven publication 

 *.jar
 Dependencies

Every  JVM Language uses components["java"]
            artifacts.removeIf { artifact ->
                artifact.classifier in setOf("sources", "javadoc")
            }
            
 
 sources.jar and  javadoc.jar can be excluded from the publication 
            artifact(file("build/libs/artifact.zip")) {
            
    
Alternatively,  atifacts can be included 

The published file name is [project]-[version]-[classifier].[extension]
                classifier = "artifact-name"
                extension = "zip"
                builtBy(tasks["taskName"])
                
    
The  task used to produce this  atifact can be referenced
            }
            artifact(tasks["taskName"])
            
            
 atifacts can also be included by  task output
        } 
    } 

    repositories { 
    repositories { 
    
      
 Maven repositories to publish to are listed here 

        mavenLocal()
        
     
Maven Local is the local respository on your machine

By default it is located at ~/.m2/repository 
It is redundant to include it, a  task for it is generated by default 

 Gradle Docs — Local Maven Repository 
Maven Local 

        maven { 
        maven { 
        
   
Publish to  GitHub Packages 

 GitHub Docs — Gradle Publish 
            name = "GitHubPackages"
            url = uri("https://maven.pkg.github.com/OWNER/REPOSITORY")
            credentials {
                username = System.getenv("GITHUB_ACTOR")
                password = System.getenv("GITHUB_TOKEN")
            }
        } 

        maven { 
        maven { 
        
   
Publish to  Sonatype Nexus 

 Sonatype Docs — Nexus Gradle Publish 
            name = "Nexus"
            url = uri("http://nexus.username.me/repository/repository-name")
            credentials {
                username = System.getenv("NEXUS_USER")
                password = System.getenv("NEXUS_PASS")
            }
        } 

        maven { 
        maven { 
        
   
Publish to  JFrog Artifactory 

 JFrog Docs — Artifactory Gradle Publish 
            name = "Artifactory"
            url = uri("http://artifactory.username.me/artifactory/libs-snapshot-local")
            credentials {
                username = System.getenv("ARTIFACTORY_USER")
                password = System.getenv("ARTIFACTORY_PASS")
            }
        } 
    } 
} 

signing {
    sign(publishing.publications["maven"])
}