# Gradle Plugin Reference

version 9.8.0-20260812010846+0000

This page contains links and short descriptions for all the core plugins provided by Gradle itself.

## JVM languages and frameworks

Java — `java`

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

Java Library — `java-library`

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

Java Platform — `java-platform`

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

Groovy — `groovy`

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

Scala — `scala`

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

ANTLR — `antlr`

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

JVM Test Suite — `jvm-test-suite`

  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.

Test Report Aggregation — `test-report-aggregation`

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

Java Test Fixtures — `java-test-fixtures`

  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.

JVM Toolchains — `jvm-toolchains` / `jvm-toolchain-management`

  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`).

## Native languages

C++ Application — `cpp-application`

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

C++ Library — `cpp-library`

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

C++ Unit Test — `cpp-unit-test`

  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.

Swift Application — `swift-application`

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

Swift Library — `swift-library`

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

XCTest — `xctest`

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

## Packaging and distribution

Application — `application`

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

WAR — `war`

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

EAR — `ear`

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

Maven Publish — `maven-publish`

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

Ivy Publish — `ivy-publish`

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

Distribution — `distribution`

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

Java Library Distribution — `java-library-distribution`

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

## Code analysis

Checkstyle — `checkstyle`

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

PMD — `pmd`

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

JaCoCo — `jacoco`

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

JaCoCo Report Aggregation — `jacoco-report-aggregation`

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

CodeNarc — `codenarc`

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

## IDE integration

Eclipse — `eclipse` / `eclipse-wtp`

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

IntelliJ IDEA — `idea`

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

Visual Studio — `visual-studio`

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

Xcode — `xcode`

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

## Utility

Base — `base`

  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.

Wrapper — `wrapper`

  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.

Build Init — `build-init`

  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.

Signing — `signing`

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

Plugin Development — `java-gradle-plugin`

  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.

Project Report Plugin — `project-report`

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

Build Dashboard Plugin — `build-dashboard`

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

Version Catalog — `version-catalog`

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

Groovy Gradle Plugin — `groovy-gradle-plugin`

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