Gradle Plugin Reference

Compiles, tests, and packages Java source code, and provides the foundational configurations, source sets, and tasks reused by higher-level JVM plugins.

Extends the Java plugin with a proper api/implementation separation so a library exposes only its intended public dependencies to consumers.

Publishes a set of dependency constraints as a platform (Maven BOM equivalent) that other projects can align their versions against.

Adds joint Java/Groovy compilation, Groovydoc, and the groovy configuration on top of the Java plugin for building Groovy projects.

Adds Scala compilation, ScalaDoc, and Zinc-based incremental compilation on top of the Java plugin for building Scala projects.

Generates parser and lexer sources from ANTLR grammar files and wires the generated code into the Java compile task.

Declaratively models multiple test suites (unit, integration, functional) as first-class citizens with their own source sets, dependencies, and tasks. Applied automatically by the java plugin.

Aggregates the results of multiple Test task invocations (potentially spanning multiple Gradle projects) into a single HTML report.

Produces a testFixtures component so a project can share reusable test helpers, doubles, and builders with its own test source set and with downstream consumers.

Selects and provisions the JDK used to build and test. Applied automatically by JVM plugins in projects (jvm-toolchains), and used in settings.gradle(.kts) to configure toolchain download repositories (jvm-toolchain-management).

Builds an executable C++ application, with multi-variant support for debug/release, target machines, and toolchains on Windows, Linux, and macOS.

Builds a shared or static C++ library, with the same variant model as cpp-application for cross-platform builds on Windows, Linux, and macOS.

Adds a native executable test suite backed by a C test entry point, and wires it into the C variant model for Windows, Linux, and macOS.

Builds an executable Swift application, integrating with the Swift compiler and the variant model used by other native plugins on Linux and macOS.

Builds a Swift library (static or shared) and exposes it through the same variant model as swift-application on Linux and macOS.

Adds an XCTest-based test executable for Swift or Objective-C code, running against the XCTest framework on Linux and macOS.

Packages a JVM application together with its runtime classpath and generates cross-platform run, installDist, and distZip/distTar tasks with launcher scripts.

Assembles a Java web application as a WAR archive, including web.xml, static resources, and the runtime classpath under WEB-INF/lib.

Assembles a Java EE Enterprise Archive (EAR) from component modules, including the application.xml deployment descriptor and shared library modules.

Publishes artifacts to Maven-compatible repositories, generating a POM per publication and supporting local and remote repositories.

Publishes artifacts to Ivy-compatible repositories, generating an ivy.xml per publication and supporting local and remote repositories.

Defines named distributions (a set of files bundled together) and generates ZIP and tarball assemble/install tasks for each.

Creates a ZIP distribution of a Java library project that bundles the library JAR alongside its runtime dependencies for offline use.

Runs Checkstyle against Java source sets and generates HTML/XML reports; configurable via a shared Checkstyle configuration file.

Runs PMD against Java source sets and generates HTML/XML reports of code style and correctness violations.

Adds JaCoCo code coverage to Test tasks and generates coverage reports and coverage-based build verification checks.

Aggregates the results of multiple JaCoCo code coverage reports (potentially spanning multiple Gradle projects) into a single HTML report.

Runs CodeNarc against Groovy source sets and generates HTML/XML/text reports of style and correctness violations.

Generates Eclipse project metadata (.project, .classpath) and customizes how Eclipse and Buildship import your build. Use eclipse-wtp for web projects.

Generates IntelliJ IDEA project metadata (.ipr, .iml, .iws) and customizes how IntelliJ IDEA imports your build.

Generates a Visual Studio solution and per-component project files for the current C++ build so it can be opened directly in the IDE.

Generates an Xcode workspace and per-component project files for the current C++/Swift build so it can be opened directly in the IDE.

Provides the common clean, assemble, check, and build lifecycle tasks and the archive/distribution conventions reused by most other plugins. Applied transitively by any plugin that adds archives or lifecycle tasks (JVM, native, distribution), so it rarely needs to be applied directly.

Registers the wrapper task that generates the Gradle Wrapper scripts and gradle-wrapper.properties for a project. Applied automatically to the root project, so it never needs to be applied directly.

Generates a new Gradle build of a specified type (Java library, Kotlin application, and so on). Can also generate a build from a Maven POM — see Migrating from Maven to Gradle.

Digitally signs generated files and artifacts (typically with PGP), and wires signatures into Maven and Ivy publications.

Configures a project for authoring Gradle plugins in Java, Groovy, or Kotlin; adds the gradleApi() dependency, registers plugin descriptors, and enables TestKit and plugin publishing.

Adds reporting tasks that produce project information, task graphs, and dependency listings for inspecting a build.

Generates a single HTML dashboard that links to every report produced by the build (test results, coverage, static analysis, and more).

Declares a shareable dependency version catalog and publishes it as a TOML artifact so other projects can consume it via versionCatalogs.

Configures a project to author Gradle plugins as precompiled Groovy DSL scripts in src/main/groovy, without hand-writing a plugin class.