Gradle User Guide Documentation

Guides

• 1. Declaring dependencies
• 2. Dependency Configurations
• 3. Declaring repositories
• 4. Centralizing dependencies
• 5. Dependency Constraints and Conflict Resolution
• 6. Dependency Resolution
• 7. Variant Aware Dependency Resolution
• A Groovy Build Script Primer
• Advanced Tasks
• Aligning dependency versions
• Artifact Resolution
• Artifact Transforms
• Artifact Views
• Avoiding Unnecessary Task Configuration
• Build Cache
• Build File Basics
• Build Init Plugin
• Build Lifecycle
• Build Scans
• Build cache performance
• Building C++ projects
• Building Java & JVM projects
• Building Play applications
• Building Swift projects
• Building native software
• C++ Application
• C++ Library
• C++ Unit Test
• Caching Android projects
• Caching Java projects
• Capabilities
• Centralizing Repository Declarations
• Command-Line Interface Basics
• Command-Line Interface Reference
• Compatibility Matrix
• Composite Builds
• Configuration On Demand
• Configuration cache
• Configuring Tasks Lazily
• Configuring the Build Environment
• Continuous Builds
• Controlling Task Execution
• Customizing publishing
• Dataflow Actions
• Dealing with validation problems
• Debugging and diagnosing cache misses
• Declaring Dependencies Basics
• Declaring Dependencies between Subprojects
• Declaring Dependency Configurations
• Declaring Dependency Constraints
• Declaring Repositories Basics
• Declaring Versions and Ranges
• Dependency Caching
• Dependency Graph Resolution
• Dependency Management
• Dependency Management Basics
• Dependency Resolution
• Developing Parallel Tasks
• File System Watching
• Filtering Repository Content
• Getting Started
• Getting Started
• Glossary
• Gradle & Third-party Tools
• Gradle Basics
• Gradle Daemon
• Gradle Directories
• Gradle Incremental Builds and Build Caching
• Gradle Kotlin DSL Primer
• Gradle Plugin Development Plugin
• Gradle Plugin Reference
• Gradle Quick Start
• Gradle User Manual
• Gradle User Manual: Version 8.13
• Gradle Wrapper Basics
• Gradle Wrapper Reference
• Gradle in IDEs
• Gradle-managed Directories
• How to share outputs between projects
• Implementing Binary Plugins
• Implementing Custom Tasks
• Implementing Pre-compiled Script Plugins
• Implementing model rules in a plugin
• Important concepts
• Improve the Performance of Gradle Builds
• Incremental build
• Initialization Scripts
• Inspecting Gradle Builds
• Installing Gradle
• Isolated Projects
• License Information
• Locking Versions
• Logging
• Managing Dependencies of JVM Projects
• Metadata Formats
• Migrating Builds From Apache Ant
• Migrating Builds From Apache Maven
• Migrating build logic from Groovy to Kotlin
• Modeling library features
• Modifying Dependency Metadata
• Multi-Project Build Basics
• Organizing Gradle Projects
• Organizing Tasks
• Part 1: Initializing the Project
• Part 1: Initializing the Project
• Part 2: Running Gradle Tasks
• Part 2: The Build Lifecycle
• Part 3: Dependency Management
• Part 3: Multi-Project Builds
• Part 4: Applying Gradle Plugins
• Part 4: Writing the Settings File
• Part 5: Exploring Incremental Builds
• Part 5: Writing a Build Script
• Part 6: Enabling the Gradle Build Cache
• Part 6: Writing Tasks
• Part 7: Using Gradle’s Reference Materials
• Part 7: Writing Plugins
• Platforms
• Plugin Basics
• Preventing accidental dependency upgrades
• Publishing Plugins to the Gradle Plugin Portal
• Publishing a project as module
• Repository Types
• Settings File Basics
• Sharing Build Logic between Subprojects
• Signing artifacts
• Solving common problems
• Structuring Projects with Gradle
• Supported Protocols
• Swift Application
• Swift Library
• Task Basics
• Test Reporting API
• Testing Build Logic with TestKit
• Testing Gradle plugins
• Testing in C++ projects
• Testing in Java & JVM projects
• Testing in Swift projects
• The ANTLR Plugin
• The Application Plugin
• The Base Plugin
• The Build Dashboard Plugin
• The Checkstyle Plugin
• The CodeNarc Plugin
• The Distribution Plugin
• The Ear Plugin
• The Eclipse Plugins
• The Feature Lifecycle
• The Groovy Plugin
• The IDEA Plugin
• The Ivy Publish Plugin
• The JVM Test Suite Plugin
• The JaCoCo Plugin
• The JaCoCo Report Aggregation Plugin
• The Java Library Distribution Plugin
• The Java Library Plugin
• The Java Platform Plugin
• The Java Plugin
• The Maven Publish Plugin
• The PMD Plugin
• The Project Report Plugin
• The Scala Plugin
• The Signing Plugin
• The Test Report Aggregation Plugin
• The War Plugin
• Toolchain Resolver Plugins
• Toolchains for JVM projects
• Tooling API
• Troubleshooting builds
• Troubleshooting version catalog problems
• Understanding Collections
• Understanding Gradle Module Metadata
• Understanding Implementation Options for Plugins
• Understanding Plugins
• Understanding Properties and Providers
• Understanding Services and Service Injection
• Understanding Tasks
• Understanding Variant Selection
• Understanding the Dependency Resolution Model
• Upgrading your build from Gradle 4.x to 5.0
• Upgrading your build from Gradle 5.x to 6.0
• Upgrading your build from Gradle 6.x to 7.0
• Upgrading your build from Gradle 7.x to 8.0
• Upgrading your build from Gradle 8.x to the latest
• Use cases for the build cache
• Using Ant from Gradle
• Using Catalogs with Platforms
• Using Plugins
• Using Resolution Rules
• Using Shared Build Services
• Using Tasks
• Variants and Attributes
• Verifying dependencies
• Version Catalogs
• Viewing Dependencies
• Visual Studio
• Working With Files
• Writing Build Scripts
• Writing Plugins
• Writing Settings Files
• Writing Tasks
• XCTest
• Xcode

Sections

• 1. Authoring Gradle Builds Basics - Getting Started
• 1. Core plugins - Plugin Basics
• 1. DomainObjectSet - Understanding Collections
• 1. Forcing Dependency Versions - Using Resolution Rules
• 1. Gradle Core Concepts - Getting Started
• 1. Graph Resolution - 6. Dependency Resolution
• 1. Graph Resolution - Dependency Resolution
• 1. Internal - The Feature Lifecycle
• 1. ObjectFactory - Understanding Services and Service Injection
• 1. Performing variant reselection - Artifact Views
• 1. The Basics - Dependency Management
• 1. The dependency cache - Dependency Caching
• 10. TestEventReporterFactory - Understanding Services and Service Injection
• 2. Artifact Resolution - 6. Dependency Resolution
• 2. Artifact Resolution - Dependency Resolution
• 2. Authoring Gradle Builds Tutorial - Getting Started
• 2. Changing dependencies - Dependency Caching
• 2. Community plugins - Plugin Basics
• 2. Declaring Dependencies - Dependency Management
• 2. Gradle Tutorial - Getting Started
• 2. Incubating - The Feature Lifecycle
• 2. Module Replacement - Using Resolution Rules
• 2. NamedDomainObjectSet - Understanding Collections
• 2. Performing lenient artifact selection and resolution - Artifact Views
• 2. ProjectLayout - Understanding Services and Service Injection
• 3. BuildLayout - Understanding Services and Service Injection
• 3. Declaring Repositories - Dependency Management
• 3. Dependency Substitution - Using Resolution Rules
• 3. Filtering selected artifacts - Artifact Views
• 3. Local plugins - Plugin Basics
• 3. NamedDomainObjectList - Understanding Collections
• 3. Public - The Feature Lifecycle
• 3. Using offline mode - Dependency Caching
• 4. Centralizing Dependencies - Dependency Management
• 4. Component Selection Rules - Using Resolution Rules
• 4. Deprecated - The Feature Lifecycle
• 4. Force-refreshing dependencies - Dependency Caching
• 4. NamedDomainObjectContainer - Understanding Collections
• 4. ProviderFactory - Understanding Services and Service Injection
• 4. Triggering artifact transforms - Artifact Views
• 5. Default Dependencies - Using Resolution Rules
• 5. ExtensiblePolymorphicDomainObjectContainer - Understanding Collections
• 5. Managing Dependencies - Dependency Management
• 5. WorkerExecutor - Understanding Services and Service Injection
• 6. Excluding Transitive Dependencies - Using Resolution Rules
• 6. FileSystemOperations - Understanding Services and Service Injection
• 6. Understanding Dependency Resolution - Dependency Management
• 7. ArchiveOperations - Understanding Services and Service Injection
• 7. Controlling Dependency Resolution - Dependency Management
• 7. Force Failed Resolution Strategies - Using Resolution Rules
• 8. Disabling Transitive Dependencies - Using Resolution Rules
• 8. ExecOperations - Understanding Services and Service Injection
• 8. Publishing Libraries - Dependency Management
• 9. Dependency Resolve Rules and Other Conditionals - Using Resolution Rules
• 9. ToolingModelBuilderRegistry - Understanding Services and Service Injection
• A - Glossary
• A coded example - 7. Variant Aware Dependency Resolution
• A simple multi-project build - Structuring Projects with Gradle
• API and implementation separation - The Java Library Plugin
• API and runtime separation - The Java Platform Plugin
• AUTHORING GRADLE BUILDS - Gradle User Manual: Version 8.13
• Accelerate developer builds by reusing CI results - Use cases for the build cache
• Accessing a catalog - Version Catalogs
• Accessing the build service concurrently - Using Shared Build Services
• Accessor name clash - Troubleshooting version catalog problems
• Account setup - Publishing Plugins to the Gradle Plugin Portal
• Achieving stable task inputs - Solving common problems
• Activate locking for a buildscript classpath configuration - Locking Versions
• Activate locking for all configurations - Locking Versions
• Activate locking for specific configurations - Locking Versions
• Adding a dependency - 1. Declaring dependencies
• Adding a subproject - Structuring Projects with Gradle
• Adding constraints on transitive dependencies - Declaring Dependency Constraints
• Adding custom artifacts to a publication - Customizing publishing
• Adding default configuration as conventions - Implementing Pre-compiled Script Plugins
• Adding default configuration with conventions - Implementing Binary Plugins
• Adding dependencies - Controlling Task Execution
• Adding external dependencies - Initialization Scripts
• Adding keys manually to the keyring - Verifying dependencies
• Adding missing capabilities to detect conflicts - Modifying Dependency Metadata
• Adding plugins to the Scala compiler - The Scala Plugin
• Adding the Gradle Wrapper - Gradle Wrapper Reference
• Adding the Plugin Publishing Plugin - Publishing Plugins to the Gradle Plugin Portal
• Adding variants for native jars - Modifying Dependency Metadata
• Adoption steps - Configuration cache
• Advanced techniques - Incremental build
• Alias not finished - Troubleshooting version catalog problems
• Aligning versions natively with Gradle - Aligning dependency versions
• Aligning versions of modules not published with Gradle - Aligning dependency versions
• Always define a settings file - Organizing Gradle Projects
• Analyzing performance in build scans - Build cache performance
• Android - Compatibility Matrix
• Android Studio - Gradle in IDEs
• Annotating inputs and outputs - Implementing Custom Tasks
• Annotation is incompatible with the property type - Dealing with validation problems
• Annotation is invalid in a particular context - Dealing with validation problems
• Annotation processors and Kotlin - Caching Android projects
• Annotations on ignored properties - Dealing with validation problems
• Annotations on private getters - Dealing with validation problems
• Annotations on private methods - Dealing with validation problems
• Application extension - The Application Plugin
• Applying a convention to a property - Configuring Tasks Lazily
• Applying additional rules - Implementing model rules in a plugin
• Applying external plugins - Implementing Pre-compiled Script Plugins
• Applying plugins - Initialization Scripts
• Applying plugins - Migrating build logic from Groovy to Kotlin
• Applying plugins - Plugin Basics
• Applying plugins - Using Plugins
• Artifact Transforms Overview - Artifact Transforms
• Artifact selection - Artifact Resolution
• Assembling or building dependents - Building native software
• Auto-detection of installed toolchains - Toolchains for JVM projects
• Auto-provisioning - Toolchains for JVM projects
• Automatic configuration of groovyClasspath - The Groovy Plugin
• Automatic configuration of scalaClasspath - The Scala Plugin
• Available collections - Understanding Collections
• Available mechanisms - Configuring the Build Environment
• Available services - Understanding Services and Service Injection
• Available tasks - Task Basics
• Avoid changing inputs external to your build - Solving common problems
• Avoid overlapping task outputs - Organizing Gradle Projects
• B - Glossary
• Backward compatibility policy - The Feature Lifecycle
• Base Plugin - The Distribution Plugin
• Before you begin - Part 7: Using Gradle’s Reference Materials
• Before you start migrating - Migrating build logic from Groovy to Kotlin
• Benefits of declaring task inputs and outputs - Incremental build
• Benefits of plugins - Using Plugins
• Better reuse via input normalization - Important concepts
• Binary Plugins - Writing Plugins
• Binary plugins - Understanding Plugins
• Blocks - A Groovy Build Script Primer
• Bootstrapping new projects - Command-Line Interface Reference
• Build Phases - Build Lifecycle
• Build Scans - Build Scans
• Build Script structure - Writing Build Scripts
• Build Scripting - Writing Build Scripts
• Build Scripts - Writing Build Scripts
• Build cache key - Important concepts
• Build caching - Gradle Incremental Builds and Build Caching
• Build init types - Build Init Plugin
• Build logic constraints - Isolated Projects
• Build scripts - Build File Basics
• Build variants - C++ Application
• Build variants - C++ Library
• Build variants - C++ Unit Test
• Build variants - Swift Application
• Build variants - Swift Library
• Build variants - XCTest
• Building C++ applications - Building C++ projects
• Building C++ libraries - Building C++ projects
• Building JVM applications - The Application Plugin
• Building JVM components - Building Java & JVM projects
• Building Java EE applications - Building Java & JVM projects
• Building Java Platforms - Building Java & JVM projects
• Building Java applications - Building Java & JVM projects
• Building Java libraries - Building Java & JVM projects
• Building Java web applications - Building Java & JVM projects
• Building Modules for the Java Module System - The Java Library Plugin
• Building Swift applications - Building Swift projects
• Building Swift libraries - Building Swift projects
• Building a distribution - The Application Plugin
• Building a library - Building native software
• Building an executable - Building native software
• Building applications using the Java Module System - The Application Plugin
• Building other JVM language projects - Building Java & JVM projects
• Built-in task types - Using Tasks
• C - Glossary
• CENTRALIZING DEPENDENCIES - Gradle User Manual: Version 8.13
• CONTROLLING DEPENDENCY RESOLUTION - Gradle User Manual: Version 8.13
• CORE CONCEPTS - Gradle User Manual: Version 8.13
• CORE PLUGINS - Gradle User Manual: Version 8.13
• CUnit support - Building native software
• Cache impact on CI builds - Build cache performance
• Cacheable tasks - Build Cache
• Caching tasks - Understanding Tasks
• Cancellation and timeouts - Developing Parallel Tasks
• Cannot use an input with an unknown implementation - Dealing with validation problems
• Cannot write to an output file or directory - Dealing with validation problems
• Cannot write to reserved location - Dealing with validation problems
• Captured Information - Build Scans
• Catalog file doesn’t exist - Troubleshooting version catalog problems
• ChangeLog - Isolated Projects
• Changes in detail - Upgrading your build from Gradle 4.x to 5.0
• Changing the amount of memory given to Checkstyle - The Checkstyle Plugin
• Changing the catalog name - Version Catalogs
• Changing what Gradle logs - Logging
• Check Daemon status - Gradle Daemon
• Choosing a log level - Logging
• Cleaning the build - Building C++ projects
• Cleaning the build - Building Java & JVM projects
• Cleaning the build - Building Swift projects
• Cleaning up the verification file - Verifying dependencies
• Code analysis - Gradle Plugin Reference
• Combine remote results with local caching - Use cases for the build cache
• Command Line options - Advanced Tasks
• Command-line completion - Command-Line Interface Reference
• Command-line flags - Configuring the Build Environment
• Command-line usage - Command-Line Interface Basics
• Command-line usage - Command-Line Interface Reference
• Common tasks - Command-Line Interface Reference
• Compatibility - Gradle Daemon
• Compilation avoidance - The Java Plugin
• Compiling and linking your code - Building C++ projects
• Compiling and linking your code - Building Swift projects
• Compiling and testing for Java 6 or Java 7 - The Groovy Plugin
• Compiling in external process - The Scala Plugin
• Compiling your code - Building Java & JVM projects
• Complete example - The Ivy Publish Plugin
• Complete example - The Maven Publish Plugin
• Components - Understanding Variant Selection
• Configuration - The Build Dashboard Plugin
• Configuration - The Checkstyle Plugin
• Configuration - The CodeNarc Plugin
• Configuration - The Eclipse Plugins
• Configuration - The IDEA Plugin
• Configuration - The JVM Test Suite Plugin
• Configuration - The PMD Plugin
• Configuration - Visual Studio
• Configuration - Xcode
• Configuration Examples - The JVM Test Suite Plugin
• Configuration avoidance - Migrating build logic from Groovy to Kotlin
• Configuration flags and roles - Declaring Dependency Configurations
• Configuration inheritance - Declaring Dependency Configurations
• Configurations and dependencies - Migrating build logic from Groovy to Kotlin
• Configure a task - Writing Tasks
• Configure dependencies of a test suite - The JVM Test Suite Plugin
• Configure dependencies of a test suite to reference project outputs - The JVM Test Suite Plugin
• Configure source directories of a test suite - The JVM Test Suite Plugin
• Configure the Build Cache - Build Cache
• Configure the Test task for a test suite - The JVM Test Suite Plugin
• Configure the built-in test suite - The JVM Test Suite Plugin
• Configuring authentication schemes - Supported Protocols
• Configuring integration tests - Migrating Builds From Apache Maven
• Configuring integration tests - Testing in Java & JVM projects
• Configuring plugins - Migrating build logic from Groovy to Kotlin
• Configuring publishing tasks - Customizing publishing
• Configuring tasks - Migrating build logic from Groovy to Kotlin
• Configuring the Daemon JVM - Gradle Daemon
• Configuring the JaCoCo Plugin - The JaCoCo Plugin
• Configuring the Plugin Publishing Plugin - Publishing Plugins to the Gradle Plugin Portal
• Configuring the Zinc compiler - The Scala Plugin
• Configuring the compiler, assembler and linker - Building native software
• Configuring the lock file name and location - Locking Versions
• Conflicting annotations - Dealing with validation problems
• Connecting properties together - Configuring Tasks Lazily
• Considerations and possible solutions - How to share outputs between projects
• Constructor injection - Understanding Services and Service Injection
• Consume the published plugin - Publishing Plugins to the Gradle Plugin Portal
• Consuming platforms - The Java Platform Plugin
• Continuous Integration - Gradle Daemon
• Continuous build - Command-Line Interface Reference
• Continuous integration - Gradle & Third-party Tools
• Contributed extension - The ANTLR Plugin
• Contributed extension - The Java Plugin
• Contributed extensions - The Base Plugin
• Controlling Resolution - Dependency Resolution
• Controlling the ANTLR generator process - The ANTLR Plugin
• Controlling the build environment - Testing Build Logic with TestKit
• Convention plugins - Understanding Plugins
• Convention properties (deprecated) - The ANTLR Plugin
• Convention properties (deprecated) - The Application Plugin
• Convention properties (deprecated) - The Java Plugin
• Convention properties (deprecated) - The War Plugin
• Convention properties (ear) - The Ear Plugin
• Convention properties - The Groovy Plugin
• Convention properties - The Project Report Plugin
• Convention properties - The Scala Plugin
• Conventions (deprecated) - The Base Plugin
• Conventions - C++ Application
• Conventions - C++ Library
• Conventions - C++ Unit Test
• Conventions - Swift Application
• Conventions - Swift Library
• Conventions - XCTest
• Copying files - Working With Files
• Copyright - Gradle User Manual
• Create a task - Writing Tasks
• Create builds for specific developer workflows - Improve the Performance of Gradle Builds
• Creating "uber" or "fat" JARs - Working With Files
• Creating a Property or Provider instance - Configuring Tasks Lazily
• Creating a catalog - Version Catalogs
• Creating a platform - Platforms
• Creating a plugin ID - Implementing Binary Plugins
• Creating and publishing custom components - Customizing publishing
• Creating archives - Working With Files
• Creating attributes in a build script or plugin - Variants and Attributes
• Creating custom configurations - Declaring Dependency Configurations
• Creating directories - Working With Files
• Creating lazy inputs and outputs - Implementing Custom Tasks
• Creating tasks - Migrating build logic from Groovy to Kotlin
• Current limitations - Isolated Projects
• Custom and third party tasks - Solving common problems
• Custom plugins - Understanding Plugins
• Custom toolchain locations - Toolchains for JVM projects
• Customizing - The Ear Plugin
• Customizing - The War Plugin
• Customizing artifact selection - Artifact Resolution
• Customizing the Gradle Wrapper - Gradle Wrapper Reference
• Customizing the HTML report - The Checkstyle Plugin
• Customizing the generated files - The Eclipse Plugins
• Customizing the generated files - The IDEA Plugin
• D - Glossary
• DECLARING DEPENDENCIES - Gradle User Manual: Version 8.13
• DECLARING REPOSITORIES - Gradle User Manual: Version 8.13
• DEPENDENCY MANAGEMENT - Gradle User Manual: Version 8.13
• DEVELOPING PLUGINS - Gradle User Manual: Version 8.13
• DEVELOPING TASKS - Gradle User Manual: Version 8.13
• DPE University - Gradle Quick Start
• Dealing with a verification failure - Verifying dependencies
• Dealing with attribute matching - Variants and Attributes
• Dealing with custom Ant tasks - Migrating Builds From Apache Ant
• Dealing with ephemeral builds - Dependency Caching
• Dealing with uncommon and custom plugins - Migrating Builds From Apache Maven
• Debugging IDE integration - Troubleshooting builds
• Debugging build logic - Testing Build Logic with TestKit
• Debugging build logic - Troubleshooting builds
• Debugging dependency resolution - Troubleshooting builds
• Debugging options - Command-Line Interface Reference
• Debugging when running tests - Testing in Java & JVM projects
• Declare an additional test suite - The JVM Test Suite Plugin
• Declare properties in gradle.properties file - Organizing Gradle Projects
• Declaring Your Dependencies - Dependency Management Basics
• Declaring a DSL configuration container - Implementing Binary Plugins
• Declaring a custom repository by URL - Declaring Repositories Basics
• Declaring a local repository - 3. Declaring repositories
• Declaring a private or custom repository - 3. Declaring repositories
• Declaring a public repository - 3. Declaring repositories
• Declaring a publicly-available repository - Declaring Repositories Basics
• Declaring a repository filter - Filtering Repository Content
• Declaring changing versions - Declaring Versions and Ranges
• Declaring common Java repositories - Managing Dependencies of JVM Projects
• Declaring component capabilities - Capabilities
• Declaring constraints alongside direct dependencies - Declaring Dependency Constraints
• Declaring content exclusively found in one repository - Filtering Repository Content
• Declaring custom attributes - Variants and Attributes
• Declaring dependencies substituted by an included build - Composite Builds
• Declaring dynamic versions - Declaring Versions and Ranges
• Declaring inputs and outputs - Implementing Custom Tasks
• Declaring inputs and outputs via annotations - Incremental build
• Declaring inputs and outputs via the runtime API - Incremental build
• Declaring module dependencies - Managing Dependencies of JVM Projects
• Declaring multiple repositories - Declaring Repositories Basics
• Declaring rich versions - Declaring Versions and Ranges
• Declaring without version - Declaring Versions and Ranges
• Declaring your source files - Building C++ projects
• Declaring your source files - Building Swift projects
• Declaring your source files via source sets - Building Java & JVM projects
• Decoupled projects - Configuration On Demand
• Default imports - Writing Build Scripts
• Defining a composite build - Composite Builds
• Deleting files and directories - Working With Files
• Dependencies on features - Modeling library features
• Dependency management - C++ Application
• Dependency management - C++ Library
• Dependency management - C++ Unit Test
• Dependency management - Swift Application
• Dependency management - Swift Library
• Dependency management - The ANTLR Plugin
• Dependency management - The Base Plugin
• Dependency management - The Build Dashboard Plugin
• Dependency management - The Checkstyle Plugin
• Dependency management - The CodeNarc Plugin
• Dependency management - The Ear Plugin
• Dependency management - The Groovy Plugin
• Dependency management - The JaCoCo Plugin
• Dependency management - The JaCoCo Report Aggregation Plugin
• Dependency management - The Java Plugin
• Dependency management - The PMD Plugin
• Dependency management - The Project Report Plugin
• Dependency management - The Test Report Aggregation Plugin
• Dependency management - The War Plugin
• Dependency management - XCTest
• Dependency resolution - Declaring Dependency Configurations
• Dependency verification options - Command-Line Interface Reference
• Depending on another project - Declaring Dependencies between Subprojects
• Depending on artifacts produced by another project - Declaring Dependencies between Subprojects
• Depending on tasks in an included build - Composite Builds
• Deploying single files into application servers - Working With Files
• Deprecated configurations - Declaring Dependency Configurations
• Developing tasks - Understanding Tasks
• Diagnosing the reasons for a cache miss - Debugging and diagnosing cache misses
• Differences between similar methods on JvmTestSuite and Test task types - The JVM Test Suite Plugin
• Differences between the test suite dependencies and the top-level dependencies blocks - The JVM Test Suite Plugin
• Disable - File System Watching
• Disable Daemon - Gradle Daemon
• Disable locking for specific configurations - Locking Versions
• Disabling Gradle Module Metadata publication - Understanding Gradle Module Metadata
• Disabling dependency locking - Locking Versions
• Disabling dependency verification for some configurations only - Verifying dependencies
• Disabling verification or making it lenient - Verifying dependencies
• Disambiguation - Caching Android projects
• Dissecting a typical build script - Managing Dependencies of JVM Projects
• Distributing a library - The Java Library Plugin
• Distribution contents - The Distribution Plugin
• Do not use cross-project configuration - Sharing Build Logic between Subprojects
• Documenting dependencies - Declaring Dependencies Basics
• E - Glossary
• Eager APIs to avoid - Avoiding Unnecessary Task Configuration
• Ear - The Ear Plugin
• Eclipse - Gradle in IDEs
• Eclipse Integration - The Scala Plugin
• Education - Gradle User Manual
• Embedded Kotlin - Gradle Kotlin DSL Primer
• Embedding Gradle using the Tooling API - Tooling API
• Enable - File System Watching
• Enable Build Scans - Build Scans
• Enable Daemon - Gradle Daemon
• Enable caching of non-cacheable tasks - Build Cache
• Enable configuration-on-demand - Configuration On Demand
• Enable incremental build for custom tasks - Improve the Performance of Gradle Builds
• Enable parallel execution - Improve the Performance of Gradle Builds
• Enable the Build Cache - Build Cache
• Enable the build cache - Improve the Performance of Gradle Builds
• Enable the configuration cache - Improve the Performance of Gradle Builds
• Enabling Java preview features - Building Java & JVM projects
• Enabling dependency verification - Verifying dependencies
• Endorsing strict versions - Declaring Versions and Ranges
• Enforcing code coverage metrics - The JaCoCo Plugin
• Environment options - Command-Line Interface Reference
• Environment variable tracking - Solving common problems
• Environment variables - Configuring the Build Environment
• Example - Debugging and diagnosing cache misses
• Example: Sign and publish a project - Signing artifacts
• Exclude tasks from execution - Controlling Task Execution
• Executing Artifact Transforms - Artifact Transforms
• Execution options - Command-Line Interface Reference
• F - Glossary
• Failing on version conflict - Preventing accidental dependency upgrades
• Feature States - The Feature Lifecycle
• Features - Building native software
• Filter using Maven metadata - Modifying Dependency Metadata
• Filtering file content - Working With Files
• Filtering files - Working With Files
• Filtering resources - Migrating Builds From Apache Maven
• Finalizer tasks - Controlling Task Execution
• Find Daemons - Gradle Daemon
• Finding out more about your project - Building native software
• Finding problems with task output caching - Debugging and diagnosing cache misses
• Fixing incorrect dependency details - Modifying Dependency Metadata
• Flat directory repository - Repository Types
• For Build Engineers and Plugin Developers - Gradle Quick Start
• For Software Developers - Gradle Quick Start
• For all users - Upgrading your build from Gradle 4.x to 5.0
• Forcing tests to run - Testing in Java & JVM projects
• Forcing use of local keyrings only - Verifying dependencies
• Fully cached builds - Build cache performance
• Functional testing with the Gradle runner - Testing Build Logic with TestKit
• Further reading - Migrating Builds From Apache Ant
• Further reading - Migrating Builds From Apache Maven
• Further things to consider - The IDEA Plugin
• G - Glossary
• GRADLE DSL/API - Gradle User Manual: Version 8.13
• GRADLE TYPES - Gradle User Manual: Version 8.13
• General guidelines - Migrating Builds From Apache Ant
• General guidelines - Migrating Builds From Apache Maven
• Generate SARIF report - The Checkstyle Plugin
• Generating API documentation - Building Java & JVM projects
• Generating and updating dependency locks - Locking Versions
• Get a holistic view using Build Scans - Viewing Dependencies
• Getting Started - The JaCoCo Plugin
• Getting additional help - Troubleshooting builds
• Getting consistent dependency resolution results - Preventing accidental dependency upgrades
• Getting the plugin-under-test into the test build - Testing Build Logic with TestKit
• Global lifecycle tasks - Organizing Tasks
• GoogleTest support - Building native software
• Gradle Build Scan Plugin - License Information
• Gradle Build Tool - Gradle User Manual
• Gradle Documentation - License Information
• Gradle Installation - Installing Gradle
• Gradle Module Metadata reproducibility - Understanding Gradle Module Metadata
• Gradle Module Metadata validation - Understanding Gradle Module Metadata
• Gradle User Home directory - Gradle Directories
• Gradle User Home directory - Gradle-managed Directories
• Gradle core concepts - Gradle Basics
• Gradle distribution-specific dependencies - Declaring Dependencies Basics
• Gradle project structure - Gradle Basics
• Gradle properties - Configuring the Build Environment
• Groovy - Compatibility Matrix
• GroovyCompile - The Groovy Plugin
• Grouping tasks - Understanding Tasks
• Guidelines - Avoiding Unnecessary Task Configuration
• H - Glossary
• HOW TO GUIDES - Gradle User Manual: Version 8.13
• Handling credentials - Supported Protocols
• Handling inconsistent module versions - Aligning dependency versions
• Handling mutually exclusive variants - Modeling library features
• Handling of credentials and secrets - Configuration cache
• Hardcoded paths and laziness - Working With Files
• Helpful data for diagnosing a cache miss - Debugging and diagnosing cache misses
• How do I use it? - Isolated Projects
• How does it work? - Incremental build
• How to integrate with Gradle - Gradle & Third-party Tools
• How to set up an HTTP build cache backend - Build Cache
• I - Glossary
• IDE integration - Gradle Plugin Reference
• IDE support - Configuration cache
• IDE support - Gradle Kotlin DSL Primer
• IDEs - Gradle & Third-party Tools
• INTEGRATION - Gradle User Manual: Version 8.13
• Identify the selected version using the dependencyInsight task - Viewing Dependencies
• Identifying additional test directories - The IDEA Plugin
• Identifying project structure - Multi-Project Build Basics
• Ignoring specific dependencies from the lock state - Locking Versions
• Implement your own Build Cache - Build Cache
• Implementing Artifact Transforms - Artifact Transforms
• Implementing a build service - Using Shared Build Services
• Implementing a dataflow action - Dataflow Actions
• Implementing automated tests - Testing Gradle plugins
• Implicit artifact selection - Artifact Resolution
• Implicit dependencies between tasks - Dealing with validation problems
• Importing a catalog from a file - Version Catalogs
• Importing a platform - Platforms
• Importing a published catalog - Version Catalogs
• Importing an Ant build - Using Ant from Gradle
• Importing multiple catalogs - Version Catalogs
• Improve the performance of older Gradle releases - Improve the Performance of Gradle Builds
• Including other resources in the distribution - The Java Library Distribution Plugin
• Incorrect use of the @Input annotation - Dealing with validation problems
• Increase the heap size - Improve the Performance of Gradle Builds
• Incremental Groovy compilation - The Groovy Plugin
• Incremental Java compilation - The Java Plugin
• Incremental annotation processing - The Java Plugin
• Incremental builds - Gradle Incremental Builds and Build Caching
• Incremental compilation - The Scala Plugin
• Incremental tasks - Advanced Tasks
• Incremental tasks - Understanding Tasks
• Input file doesn’t exist - Dealing with validation problems
• Inspect your build - Improve the Performance of Gradle Builds
• Installing Gradle - Gradle Quick Start
• Installing executables - Working With Files
• Instrumented test execution (i.e., Espresso tests) - Caching Android projects
• Integration test execution - Caching Java projects
• IntelliJ IDEA - Gradle in IDEs
• IntelliJ IDEA Integration - The Scala Plugin
• Interacting with a composite build - Composite Builds
• Interactions - Gradle Plugin Development Plugin
• Interactions with other build tools - Understanding Gradle Module Metadata
• Interoperability - Gradle Kotlin DSL Primer
• Interoperability - Migrating build logic from Groovy to Kotlin
• Introducing build variants - Building C++ projects
• Introducing build variants - Building Swift projects
• Introduction - Building C++ projects
• Introduction - Building Java & JVM projects
• Introduction - Building Swift projects
• Introduction - Configuration cache
• Invalid TOML definition - Troubleshooting version catalog problems
• Invalid alias or bundle notation - Troubleshooting version catalog problems
• Invalid annotation on method - Dealing with validation problems
• Invalid annotation on property or field - Dealing with validation problems
• Invalid dependency notation - Troubleshooting version catalog problems
• Invalid module notation - Troubleshooting version catalog problems
• Invalid plugin notation - Troubleshooting version catalog problems
• Invalid use of @Optional annotation on primitive types - Dealing with validation problems
• Invalid use of absolute path sensitivity for an artifact transform - Dealing with validation problems
• Invalid use of an output property on an artifact transforms - Dealing with validation problems
• Invalid use of annotations on fields - Dealing with validation problems
• Invalid use of cacheable annotation - Dealing with validation problems
• Invoking Gradle - Gradle Basics
• Invoking an init script - Initialization Scripts
• Isolation modes - Developing Parallel Tasks
• Ivy repositories - Repository Types
• J - Glossary
• JAVA TOOLCHAINS - Gradle User Manual: Version 8.13
• JVM BUILDS - Gradle User Manual: Version 8.13
• JVM PLUGINS - Gradle User Manual: Version 8.13
• JVM languages and frameworks - Gradle Plugin Reference
• JaCoCo Report configuration - The JaCoCo Plugin
• JaCoCo specific task configuration - The JaCoCo Plugin
• Java Runtime - Compatibility Matrix
• Java and Kotlin compilation - Caching Android projects
• Java compilation - Caching Java projects
• Java version tracking - Solving common problems
• K - Glossary
• Kotlin - Compatibility Matrix
• Kotlin DSL Plugin - Gradle Kotlin DSL Primer
• Kotlin DSL scripts - Gradle Kotlin DSL Primer
• L - Glossary
• LICENSE INFORMATION - Gradle User Manual: Version 8.13
• Language support - Building native software
• Lazy APIs to use - Avoiding Unnecessary Task Configuration
• Lazy property assignment - Gradle Kotlin DSL Primer
• Legacy Plugin Application - Using Plugins
• Library Dependencies - Building native software
• License of start scripts - The Application Plugin
• Licenses - Gradle User Manual
• Lifecycle tasks - Organizing Tasks
• Limitations - Continuous Builds
• Limitations - Gradle Kotlin DSL Primer
• Limitations of composite builds - Composite Builds
• Line endings - Solving common problems
• Lint - Caching Android projects
• Linux installation - Installing Gradle
• List available tasks - Using Tasks
• List project dependencies using the dependencies task - Viewing Dependencies
• Listing project dependencies - 1. Declaring dependencies
• Listing tasks - Understanding Tasks
• Local project constraints - The Java Platform Plugin
• Local variables - A Groovy Build Script Primer
• Locating files - Working With Files
• Logging - File System Watching
• Logging Sensitive Information - Logging
• Logging from external tools and libraries - Logging
• Logging options - Command-Line Interface Reference
• Looking at an example - 1. Declaring dependencies
• Low level profiling - Inspecting Gradle Builds
• M - Glossary
• MANAGING DEPENDENCIES - Gradle User Manual: Version 8.13
• Making Ivy modules variant-aware - Modifying Dependency Metadata
• Making a case for migration - Migrating Builds From Apache Maven
• Making a plugin configurable using extensions - Implementing Binary Plugins
• Making a plugin configurable using extensions - Implementing Pre-compiled Script Plugins
• Making a property unmodifiable - Configuring Tasks Lazily
• Making different flavors of a library available through capabilities - Modifying Dependency Metadata
• Making sure resolution is reproducible - Preventing accidental dependency upgrades
• Making variants encoded in versions explicit - Modifying Dependency Metadata
• Making variants published as classified jars explicit - Modifying Dependency Metadata
• Managing dependencies - Migrating Builds From Apache Ant
• Managing resources - Building Java & JVM projects
• Managing your dependencies - Building C++ projects
• Managing your dependencies - Building Java & JVM projects
• Managing your dependencies - Building Swift projects
• Mapping extension properties to task properties - Implementing Binary Plugins
• Mapping extension properties to task properties - Implementing Pre-compiled Script Plugins
• Mapping from Maven/Ivy to Gradle variants - Variants and Attributes
• Mapping of Ivy files to variants - Variants and Attributes
• Mapping with other formats - Understanding Gradle Module Metadata
• Maven repositories - Repository Types
• Measuring developer builds - Build cache performance
• Methods - A Groovy Build Script Primer
• Migrating Ant properties - Migrating Builds From Apache Ant
• Migrating Maven profiles and properties - Migrating Builds From Apache Maven
• Migrating common plugins - Migrating Builds From Apache Maven
• Migrating dependencies - Migrating Builds From Apache Maven
• Migrating multi-module builds (project aggregation) - Migrating Builds From Apache Maven
• Migrating multi-project builds - Migrating Builds From Apache Ant
• Migrating your legacy lockfile - Locking Versions
• Migration guide - Avoiding Unnecessary Task Configuration
• Migration strategies - Migrating build logic from Groovy to Kotlin
• Missing normalization annotation - Dealing with validation problems
• Missing reason for not caching - Dealing with validation problems
• Modeling DSL-like APIs - Implementing Binary Plugins
• Modifying a subproject path - Structuring Projects with Gradle
• Modifying and adding variants to existing components for publishing - Customizing publishing
• Modifying metadata on the component level for alignment - Modifying Dependency Metadata
• Modifying metadata on the component level for version selection based on status - Modifying Dependency Metadata
• Moving files and directories - Working With Files
• Multi-Project building and testing - Multi-Project Build Basics
• Multi-Project path - Multi-Project Build Basics
• Multi-Project standards - Multi-Project Build Basics
• Multi-Project structure - Multi-Project Build Basics
• Mutable type with setter - Dealing with validation problems
• N - Glossary
• Naming recommendations - Structuring Projects with Gradle
• Native Binary Variants - Building native software
• Native languages - Gradle Plugin Reference
• Native software model - Building native software
• NetBeans - Gradle in IDEs
• No import files - Troubleshooting version catalog problems
• Non-cacheable tasks - Important concepts
• Not yet implemented - Configuration cache
• O - Glossary
• OPTIMIZING BUILD PERFORMANCE - Gradle User Manual: Version 8.13
• OTHER TOPICS - Gradle User Manual: Version 8.13
• OVERVIEW - Gradle User Manual: Version 8.13
• Optimize Android projects - Improve the Performance of Gradle Builds
• Optimize Configuration - Improve the Performance of Gradle Builds
• Optimize Dependency resolution - Improve the Performance of Gradle Builds
• Optimize Java projects - Improve the Performance of Gradle Builds
• Ordering tasks - Controlling Task Execution
• Outgoing Variants - The JVM Test Suite Plugin
• Outgoing Variants - The JaCoCo Plugin
• Overview - Build Cache
• Overwriting catalog versions - Version Catalogs
• P - Glossary
• PLATFORMS - Gradle User Manual: Version 8.13
• PUBLISHING LIBRARIES - Gradle User Manual: Version 8.13
• Packaging and distribution - Gradle Plugin Reference
• Packaging and publishing - Building C++ projects
• Packaging and publishing - Building Java & JVM projects
• Packaging and publishing - Building Swift projects
• Parallel Compilation - Building native software
• Parallel projects - Configuration On Demand
• Performance Impact - Gradle Daemon
• Performance Monitoring - Gradle Daemon
• Performance categories - Inspecting Gradle Builds
• Performance options - Command-Line Interface Reference
• Performing an automatic conversion - Migrating Builds From Apache Maven
• Phase 1. Conflict resolution - Understanding the Dependency Resolution Model
• Phase 1. Initialization - Build Lifecycle
• Phase 2. Configuration - Build Lifecycle
• Phase 2. Dependency metadata retrieval - Understanding the Dependency Resolution Model
• Phase 3. Execution - Build Lifecycle
• Platforms - Using Catalogs with Platforms
• Plugin Management - Using Plugins
• Plugin distribution - Plugin Basics
• Plugin distribution - Using Plugins
• Plugin repositories - Declaring Repositories Basics
• Plugins Introduction - Understanding Plugins
• Plugins published without Gradle Plugin Portal - Publishing Plugins to the Gradle Plugin Portal
• Pre-compiled script plugin - Writing Plugins
• Precompiled Headers - Building native software
• Precompiled script plugins - Understanding Plugins
• Prepare your Groovy scripts - Migrating build logic from Groovy to Kotlin
• Prerequisites - Gradle Kotlin DSL Primer
• Prerequisites - Installing Gradle
• Prerequisites - Publishing Plugins to the Gradle Plugin Portal
• Priority for configurations - Configuring the Build Environment
• Private and hidden tasks - Understanding Tasks
• Profile report - Inspecting Gradle Builds
• Profile with build scans - Inspecting Gradle Builds
• Programming catalogs - Version Catalogs
• Project Descriptors - Structuring Projects with Gradle
• Project Root directory - Gradle Directories
• Project Root directory - Gradle-managed Directories
• Project layout - The ANTLR Plugin
• Project layout - The Build Dashboard Plugin
• Project layout - The Checkstyle Plugin
• Project layout - The CodeNarc Plugin
• Project layout - The Ear Plugin
• Project layout - The Groovy Plugin
• Project layout - The Java Plugin
• Project layout - The Project Report Plugin
• Project layout - The Scala Plugin
• Project layout - The War Plugin
• Project locations - Structuring Projects with Gradle
• Project properties - Configuring the Build Environment
• Project reporting - Command-Line Interface Reference
• Project vs Settings vs Init plugins - Understanding Plugins
• Properties - A Groovy Build Script Primer
• Properties without annotations - Dealing with validation problems
• Property annotated with @ServiceReference is not a BuildService - Dealing with validation problems
• Property injection - Understanding Services and Service Injection
• Provide a download URI - Toolchain Resolver Plugins
• Providing default dependencies - Implementing Binary Plugins
• Providing multiple variants of a plugin - Implementing Binary Plugins
• Publications - The Ivy Publish Plugin
• Publications - The Maven Publish Plugin
• Publishing - The Distribution Plugin
• Publishing - The Java Plugin
• Publishing - The War Plugin
• Publishing Maven relocation information - The Maven Publish Plugin
• Publishing a catalog - Version Catalogs
• Publishing artifacts - Managing Dependencies of JVM Projects
• Publishing artifacts - Migrating Builds From Apache Ant
• Publishing features - Modeling library features
• Publishing platforms - The Java Platform Plugin
• Publishing the plugin - Publishing Plugins to the Gradle Plugin Portal
• Publishing the signatures - The Signing Plugin
• Publishing to Maven Local - The Maven Publish Plugin
• Q - Glossary
• R - Glossary
• REFERENCE - Gradle User Manual: Version 8.13
• RELEASES - Gradle User Manual: Version 8.13
• RUNNING GRADLE BUILDS - Gradle User Manual: Version 8.13
• Re-enable the Gradle Daemon - Improve the Performance of Gradle Builds
• Reacting to build features - Implementing Binary Plugins
• Reacting to plugins - Implementing Binary Plugins
• Receiving information about task execution - Using Shared Build Services
• Recognizing API and implementation dependencies - The Java Library Plugin
• Redundant getters - Dealing with validation problems
• Refreshing missing keys - Verifying dependencies
• Register a task - Writing Tasks
• Register the resolver in a plugin - Toolchain Resolver Plugins
• Registering Artifact Transforms - Artifact Transforms
• Registering a build service and connecting it to a task - Using Shared Build Services
• Registering features - Modeling library features
• Release end-of-life Policy - The Feature Lifecycle
• Releases - Gradle User Manual
• Remote cache performance - Build cache performance
• Removal of deferred configuration behavior - The Maven Publish Plugin
• Renaming files - Working With Files
• Repeatable task outputs - Important concepts
• Reports - The JaCoCo Report Aggregation Plugin
• Reports - The Test Report Aggregation Plugin
• Repositories - The Ivy Publish Plugin
• Repositories - The Maven Publish Plugin
• Repositories mode - Centralizing Repository Declarations
• Required value isn’t set - Dealing with validation problems
• Requirements - Configuration cache
• Resolvable and consumable configurations - Declaring Dependency Configurations
• Resolving capability conflicts - 5. Dependency Constraints and Conflict Resolution
• Resolving unsafe configuration resolution errors - Viewing Dependencies
• Resolving version conflicts - 5. Dependency Constraints and Conflict Resolution
• Restricting publications to specific repositories - Customizing publishing
• Restrictions on included builds - Composite Builds
• Reuse of outputs between different tasks - Important concepts
• Running a build with lock state present - Locking Versions
• Running tasks - Task Basics
• Running tests - Building Java & JVM projects
• S - Glossary
• STRUCTURING BUILDS - Gradle User Manual: Version 8.13
• Sample usage - Build Init Plugin
• Scala version - The Scala Plugin
• Script file naming - Migrating build logic from Groovy to Kotlin
• Script plugin - Writing Plugins
• Script plugins - Understanding Plugins
• Selecting between candidates - Capabilities
• Selection of features via capabilities - Modeling library features
• Separate language-specific source files - Organizing Gradle Projects
• Separate source files per test type - Organizing Gradle Projects
• Separating capabilities from conventions - Implementing Binary Plugins
• Separation of test classpath entries - The Eclipse Plugins
• Setting file permissions - Working With Files
• Setting the Gradle version used to test - Testing Build Logic with TestKit
• Setting the plugin ID - Implementing Pre-compiled Script Plugins
• Setting up automated tests - Testing Gradle plugins
• Setting up basic publishing - Publishing a project as module
• Setting up manual tests - Testing Gradle plugins
• Settings File Scripting - Writing Settings Files
• Settings Script structure - Writing Settings Files
• Settings Scripts - Writing Settings Files
• Settings script - Settings File Basics
• Share logic in buildSrc - Sharing Build Logic between Subprojects
• Share logic using convention plugins - Sharing Build Logic between Subprojects
• Share results between CI builds - Use cases for the build cache
• Share results between developers - Use cases for the build cache
• Sharing configuration between multiple test suites - The JVM Test Suite Plugin
• Signatory credentials - The Signing Plugin
• Skipping Javadocs and sources - Verifying dependencies
• Skipping tasks - Controlling Task Execution
• Skipping the tests - Testing in Java & JVM projects
• Source set properties - The ANTLR Plugin
• Source set properties - The Groovy Plugin
• Source set properties - The Scala Plugin
• Source sets - The Java Plugin
• Sourcing constraints from another platform - The Java Platform Plugin
• Specifying what to sign - The Signing Plugin
• Speed up developer builds with the local cache - Use cases for the build cache
• Stable configuration cache - Configuration cache
• Stable task inputs - Important concepts
• Stale task outputs - Incremental build
• Standard attributes defined by Gradle - Variants and Attributes
• Standardizing builds with a custom Gradle distribution - Organizing Gradle Projects
• Status as of Gradle 8.11 - Isolated Projects
• Step 0. Before you Begin - Part 1: Initializing the Project
• Step 0. Before you Begin - Part 1: Initializing the Project
• Step 0. Before you Begin - Part 2: Running Gradle Tasks
• Step 0. Before you Begin - Part 2: The Build Lifecycle
• Step 0. Before you Begin - Part 3: Dependency Management
• Step 0. Before you Begin - Part 3: Multi-Project Builds
• Step 0. Before you Begin - Part 4: Applying Gradle Plugins
• Step 0. Before you Begin - Part 4: Writing the Settings File
• Step 0. Before you Begin - Part 5: Exploring Incremental Builds
• Step 0. Before you Begin - Part 5: Writing a Build Script
• Step 0. Before you Begin - Part 6: Enabling the Gradle Build Cache
• Step 0. Before you Begin - Part 6: Writing Tasks
• Step 0. Before you Begin - Part 7: Writing Plugins
• Step 1. About Multi-Project Builds - Part 3: Multi-Project Builds
• Step 1. Develop the Plugin - Part 7: Writing Plugins
• Step 1. Gradle References - Part 7: Using Gradle’s Reference Materials
• Step 1. Gradle scripts - Part 4: Writing the Settings File
• Step 1. Initializing the Project - Part 1: Initializing the Project
• Step 1. Initializing the Project - Part 1: Initializing the Project
• Step 1. The Project object - Part 5: Writing a Build Script
• Step 1. Understand Tasks - Part 6: Writing Tasks
• Step 1. Understanding Caching - Part 6: Enabling the Gradle Build Cache
• Step 1. Understanding Incremental Builds - Part 5: Exploring Incremental Builds
• Step 1. Understanding Plugins - Part 4: Applying Gradle Plugins
• Step 1. Understanding the Build Lifecycle - Part 2: The Build Lifecycle
• Step 1. Understanding the Version Catalog - Part 3: Dependency Management
• Step 1. Viewing available Tasks - Part 2: Running Gradle Tasks
• Step 2. Add a license.txt file - Part 7: Writing Plugins
• Step 2. Add another Subproject to the Build - Part 3: Multi-Project Builds
• Step 2. Applying a Plugin - Part 4: Applying Gradle Plugins
• Step 2. Enabling the Local Build Cache - Part 6: Enabling the Gradle Build Cache
• Step 2. Next steps - Part 7: Using Gradle’s Reference Materials
• Step 2. Register and Configure Tasks - Part 6: Writing Tasks
• Step 2. The Build script - Part 5: Writing a Build Script
• Step 2. The Settings object - Part 4: Writing the Settings File
• Step 2. Understanding Project Dependencies - Part 3: Dependency Management
• Step 2. Understanding Tasks - Part 2: Running Gradle Tasks
• Step 2. Understanding the Directory layout - Part 1: Initializing the Project
• Step 2. Understanding the Gradle Wrapper - Part 1: Initializing the Project
• Step 2. Update the Settings File - Part 2: The Build Lifecycle
• Step 2. Updating Gradle Properties - Part 5: Exploring Incremental Builds
• Step 3. Analyzing Incremental Builds - Part 5: Exploring Incremental Builds
• Step 3. Apply the Plugin - Part 5: Writing a Build Script
• Step 3. Apply the Plugin - Part 7: Writing Plugins
• Step 3. Configuring the Plugin - Part 4: Applying Gradle Plugins
• Step 3. Create a custom Task - Part 6: Writing Tasks
• Step 3. Invoking the Gradle Wrapper - Part 1: Initializing the Project
• Step 3. Review the Gradle Files - Part 1: Initializing the Project
• Step 3. The Settings file - Part 4: Writing the Settings File
• Step 3. Understand Composite Builds - Part 3: Multi-Project Builds
• Step 3. Understanding Dependencies Between Tasks - Part 2: Running Gradle Tasks
• Step 3. Understanding Transitive Dependencies - Part 3: Dependency Management
• Step 3. Update the Build Script - Part 2: The Build Lifecycle
• Step 3. Update the Build scripts - Part 5: Writing a Build Script
• Step 3. Using the Local Build Cache - Part 6: Enabling the Gradle Build Cache
• Step 4. Add build to the Build - Part 3: Multi-Project Builds
• Step 4. Next steps - Part 7: Writing Plugins
• Step 4. Review the Code - Part 1: Initializing the Project
• Step 4. Run a Gradle Task - Part 2: The Build Lifecycle
• Step 4. Run the custom Task - Part 7: Writing Plugins
• Step 4. Understanding Gradle’s Project Structure - Part 1: Initializing the Project
• Step 4. Understanding Outcome Labels - Part 5: Exploring Incremental Builds
• Step 4. Understanding Remote Caching - Part 6: Enabling the Gradle Build Cache
• Step 4. Using the Plugin - Part 4: Applying Gradle Plugins
• Step 4. View Plugin Task - Part 5: Writing a Build Script
• Step 4. Viewing Project Dependencies - Part 3: Dependency Management
• Step 4. Viewing Tasks in the IDE - Part 2: Running Gradle Tasks
• Step 5. Exploring Plugins - Part 4: Applying Gradle Plugins
• Step 5. Run the App - Part 1: Initializing the Project
• Step 5. Running Tasks in the IDE - Part 2: Running Gradle Tasks
• Step 5. View Plugin Tasks - Part 5: Writing a Build Script
• Step 5. Viewing Dependencies in a Build Scan® - Part 3: Dependency Management
• Step 5. Viewing Gradle files in an IDE - Part 1: Initializing the Project
• Step 6. Bundle the App - Part 1: Initializing the Project
• Step 6. Publish a Build Scan - Part 1: Initializing the Project
• Step 6. Running Tasks in the Terminal - Part 2: Running Gradle Tasks
• Step 6. Understanding the Settings file - Part 1: Initializing the Project
• Step 6. Updating Project Dependencies - Part 3: Dependency Management
• Step 7. Run the Java app - Part 3: Dependency Management
• Step 7. Understanding the Build script - Part 1: Initializing the Project
• Stop Daemon - Gradle Daemon
• Suggestions for authoring your build - Solving common problems
• Supplying the action for execution - Dataflow Actions
• Support - Gradle User Manual
• Supported File Systems - File System Watching
• Supported Gradle build types - Build Init Plugin
• Supported Operating Systems - File System Watching
• Supported languages - Building native software
• Supported metadata formats - Metadata Formats
• Supported metadata sources - Metadata Formats
• Supported plugins - Configuration cache
• Supported transport protocols - Supported Protocols
• Suppressing validation errors - Publishing a project as module
• Symbolic links - Solving common problems
• System file encoding - Solving common problems
• System properties - Configuring the Build Environment
• T - Glossary
• THE BUILD CACHE - Gradle User Manual: Version 8.13
• Target Platforms - Compatibility Matrix
• Target bytecode level and Java APIs version - The Scala Plugin
• Task - The Base Plugin
• Task Graphs - Build Lifecycle
• Task Output Caching - Build Cache
• Task actions - Implementing Custom Tasks
• Task categories - Understanding Tasks
• Task classification - Using Tasks
• Task configuration - Using Tasks
• Task configuration avoidance API - Avoiding Unnecessary Task Configuration
• Task dependencies - Controlling Task Execution
• Task dependencies - Using Tasks
• Task dependency - Task Basics
• Task group and description - Understanding Tasks
• Task group and description - Using Tasks
• Task group and description - Writing Tasks
• Task implementation by extending DefaultTask - Implementing Custom Tasks
• Task input and outputs - Writing Tasks
• Task inputs and outputs - Implementing Custom Tasks
• Task inputs and outputs - Incremental build
• Task options - Command-Line Interface Reference
• Task outcomes - Understanding Tasks
• Task registration and action - Using Tasks
• Task rules - Controlling Task Execution
• Task types - Using Tasks
• Tasks - Build Init Plugin
• Tasks - Building native software
• Tasks - C++ Application
• Tasks - C++ Library
• Tasks - C++ Unit Test
• Tasks - Swift Application
• Tasks - Swift Library
• Tasks - The ANTLR Plugin
• Tasks - The Application Plugin
• Tasks - The Build Dashboard Plugin
• Tasks - The Checkstyle Plugin
• Tasks - The CodeNarc Plugin
• Tasks - The Distribution Plugin
• Tasks - The Ear Plugin
• Tasks - The Eclipse Plugins
• Tasks - The Groovy Plugin
• Tasks - The IDEA Plugin
• Tasks - The Ivy Publish Plugin
• Tasks - The JVM Test Suite Plugin
• Tasks - The JaCoCo Plugin
• Tasks - The JaCoCo Report Aggregation Plugin
• Tasks - The Java Library Distribution Plugin
• Tasks - The Java Plugin
• Tasks - The Maven Publish Plugin
• Tasks - The PMD Plugin
• Tasks - The Project Report Plugin
• Tasks - The Scala Plugin
• Tasks - The Test Report Aggregation Plugin
• Tasks - The War Plugin
• Tasks - Visual Studio
• Tasks - XCTest
• Tasks - Xcode
• Terminating Continuous Build - Continuous Builds
• Test detection - Testing in Java & JVM projects
• Test execution - Testing in C++ projects
• Test execution - Testing in Java & JVM projects
• Test execution - Testing in Swift projects
• Test execution order in TestNG - Testing in Java & JVM projects
• Test filtering - Testing in Java & JVM projects
• Test filtering - Testing in Swift projects
• Test grouping - Testing in Java & JVM projects
• Test integration - Gradle & Third-party Tools
• Test logging - Testing in Java & JVM projects
• Test reporting - Testing in Java & JVM projects
• Test reporting - Testing in Swift projects
• Testing - The Java Plugin
• Testing Java Modules - Testing in Java & JVM projects
• Testing with the Build Cache - Testing Build Logic with TestKit
• Testing your build logic - Configuration cache
• The Android Gradle Plugin - Caching Android projects
• The Fabric Plugin and Crashlytics - Caching Android projects
• The Java Library plugin configurations - The Java Library Plugin
• The Project object - A Groovy Build Script Primer
• The Project object - Writing Build Scripts
• The Settings Object - Writing Settings Files
• The Worker API - Developing Parallel Tasks
• The basics - Testing in C++ projects
• The basics - Testing in Java & JVM projects
• The basics - Testing in Swift projects
• The case against overlapping outputs - Important concepts
• The consumer side - 7. Variant Aware Dependency Resolution
• The dependency tree - Understanding the Dependency Resolution Model
• The gradle.properties file - Configuring the Build Environment
• The importance of testing - Testing Gradle plugins
• The producer side - 7. Variant Aware Dependency Resolution
• The sample project - Testing Gradle plugins
• Too many entries in a single catalog - Troubleshooting version catalog problems
• Too many import files - Troubleshooting version catalog problems
• Too many import invocations - Troubleshooting version catalog problems
• Tool chain installation - Building native software
• Tool chain support - Building native software
• Tool chains - Building native software
• Toolchain installations precedence - Toolchains for JVM projects
• Toolchains for plugin authors - Toolchains for JVM projects
• Toolchains for projects - Toolchains for JVM projects
• Toolchains for tasks - Toolchains for JVM projects
• Toolchains limitations - Toolchains for JVM projects
• Tools & IDEs - Gradle Daemon
• Troubleshooting - Configuration cache
• Troubleshooting - File System Watching
• Troubleshooting - Gradle Kotlin DSL Primer
• Troubleshooting slow builds - Troubleshooting builds
• Troubleshooting the installation - Troubleshooting builds
• Trusting multiple checksums for an artifact - Verifying dependencies
• Trusting some particular artifacts - Verifying dependencies
• Type-safe model accessors - Gradle Kotlin DSL Primer
• Types of dependencies - Declaring Dependencies Basics
• Types of plugins - Using Plugins
• U - Glossary
• UNDERSTANDING DEPENDENCY RESOLUTION - Gradle User Manual: Version 8.13
• UPGRADING - Gradle User Manual: Version 8.13
• Undefined alias reference - Troubleshooting version catalog problems
• Undefined version reference - Troubleshooting version catalog problems
• Understanding Artifact Transforms - Artifact Transforms
• Understanding Artifact Transforms Chains - Artifact Transforms
• Understanding Lazy properties - Configuring Tasks Lazily
• Understanding Log levels - Logging
• Understanding Properties - Understanding Properties and Providers
• Understanding Providers - Understanding Properties and Providers
• Understanding capabilities - Capabilities
• Understanding capability coordinates - Capabilities
• Understanding dependency configurations - 2. Dependency Configurations
• Understanding dependency constraints - 5. Dependency Constraints and Conflict Resolution
• Understanding inputs and outputs - Implementing Custom Tasks
• Understanding lock state location and format - Locking Versions
• Understanding locking limitations - Locking Versions
• Understanding producers and consumers - 1. Declaring dependencies
• Understanding signature verification - Verifying dependencies
• Understanding supported repository types - 3. Declaring repositories
• Understanding the Daemon - Gradle Daemon
• Understanding the Wrapper files - Gradle Wrapper Basics
• Understanding the build lifecycle - Migrating Builds From Apache Maven
• Understanding types of conflicts - 5. Dependency Constraints and Conflict Resolution
• Understanding types of dependencies - 1. Declaring dependencies
• Understanding version declaration - Declaring Versions and Ranges
• Understanding version ordering - Declaring Versions and Ranges
• Understanding which plugins you don’t need - Migrating Builds From Apache Maven
• Unexpected input file or directory - Dealing with validation problems
• Unit test execution - Caching Android projects
• Unit test execution - Caching Java projects
• Unpacking archives - Working With Files
• Unsafe configuration resolution errors - Declaring Dependency Configurations
• Unsupported File Systems - File System Watching
• Unsupported TOML file format version - Troubleshooting version catalog problems
• Unsupported catalog file format - Troubleshooting version catalog problems
• Unsupported key type of nested map - Dealing with validation problems
• Unsupported nested type - Dealing with validation problems
• Unsupported notation in file inputs - Dealing with validation problems
• Unsupported value type - Dealing with validation problems
• Update versions - Improve the Performance of Gradle Builds
• Updating lock state entries selectively - Locking Versions
• Upgrading from 4.0 - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.1 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.10 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.2 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.3 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.4 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.5 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.6 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.7 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.8 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 4.9 and earlier - Upgrading your build from Gradle 4.x to 5.0
• Upgrading from 5.0 and earlier - Upgrading your build from Gradle 5.x to 6.0
• Upgrading from 5.1 and earlier - Upgrading your build from Gradle 5.x to 6.0
• Upgrading from 5.2 and earlier - Upgrading your build from Gradle 5.x to 6.0
• Upgrading from 5.3 and earlier - Upgrading your build from Gradle 5.x to 6.0
• Upgrading from 5.4 and earlier - Upgrading your build from Gradle 5.x to 6.0
• Upgrading from 5.5 and earlier - Upgrading your build from Gradle 5.x to 6.0
• Upgrading from 5.6 and earlier - Upgrading your build from Gradle 5.x to 6.0
• Upgrading from 6.0 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.1 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.2 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.3 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.4 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.5 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.6 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.7 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.8 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 6.9 and earlier - Upgrading your build from Gradle 6.x to 7.0
• Upgrading from 7.0 and earlier - Upgrading your build from Gradle 7.x to 8.0
• Upgrading from 7.1 and earlier - Upgrading your build from Gradle 7.x to 8.0
• Upgrading from 7.2 and earlier - Upgrading your build from Gradle 7.x to 8.0
• Upgrading from 7.3 and earlier - Upgrading your build from Gradle 7.x to 8.0
• Upgrading from 7.4 and earlier - Upgrading your build from Gradle 7.x to 8.0
• Upgrading from 7.5 and earlier - Upgrading your build from Gradle 7.x to 8.0
• Upgrading from 7.6 and earlier - Upgrading your build from Gradle 7.x to 8.0
• Upgrading from 8.0 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.1 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.10 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.11 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.12 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.2 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.3 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.4 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.5 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.6 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.7 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.8 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading from 8.9 and earlier - Upgrading your build from Gradle 8.x to the latest
• Upgrading the Gradle Wrapper - Gradle Wrapper Reference
• Usage - C++ Application
• Usage - C++ Library
• Usage - C++ Unit Test
• Usage - Gradle Plugin Development Plugin
• Usage - Swift Application
• Usage - Swift Library
• Usage - The ANTLR Plugin
• Usage - The Base Plugin
• Usage - The Build Dashboard Plugin
• Usage - The Checkstyle Plugin
• Usage - The CodeNarc Plugin
• Usage - The Distribution Plugin
• Usage - The Ear Plugin
• Usage - The Eclipse Plugins
• Usage - The Groovy Plugin
• Usage - The IDEA Plugin
• Usage - The Ivy Publish Plugin
• Usage - The JVM Test Suite Plugin
• Usage - The JaCoCo Report Aggregation Plugin
• Usage - The Java Library Distribution Plugin
• Usage - The Java Library Plugin
• Usage - The Java Platform Plugin
• Usage - The Java Plugin
• Usage - The Maven Publish Plugin
• Usage - The PMD Plugin
• Usage - The Project Report Plugin
• Usage - The Scala Plugin
• Usage - The Signing Plugin
• Usage - The Test Report Aggregation Plugin
• Usage - The War Plugin
• Usage - Visual Studio
• Usage - XCTest
• Usage - Xcode
• Use buildSrc to abstract imperative logic - Organizing Gradle Projects
• Use of a reserved alias name - Troubleshooting version catalog problems
• Use standard conventions as much as possible - Organizing Gradle Projects
• User Manual - Gradle User Manual
• Using Ant logging - Using Ant from Gradle
• Using Ant properties and references - Using Ant from Gradle
• Using Ant tasks and types - Using Ant from Gradle
• Using Gradle Managed Properties - Understanding Properties and Providers
• Using Gradle Managed Types - Understanding Properties and Providers
• Using JUnit 5 - Testing in Java & JVM projects
• Using Java Bean Properties - Understanding Properties and Providers
• Using TestKit - Testing Build Logic with TestKit
• Using a Version Catalog - Using Plugins
• Using a Version catalog - 4. Centralizing dependencies
• Using a build service with the Worker API - Using Shared Build Services
• Using a catalog with a platform - Using Catalogs with Platforms
• Using a custom dependencies block - Implementing Binary Plugins
• Using a platform - Platforms
• Using a standard attribute - Variants and Attributes
• Using an init script - Initialization Scripts
• Using bills of materials (BOMs) - Migrating Builds From Apache Maven
• Using classes instead of jar for compilation - The Java Library Plugin
• Using custom descriptor file - The Ear Plugin
• Using dependency configurations - Managing Dependencies of JVM Projects
• Using gpg-agent - The Signing Plugin
• Using lifecycle event providers - Dataflow Actions
• Using platforms - 4. Centralizing dependencies
• Using plugins - Using Plugins
• Using test fixtures - Testing in Java & JVM projects
• Using the Gradle Wrapper - Gradle Wrapper Basics
• Using the Gradle Wrapper - Gradle Wrapper Reference
• Using the Plugin Development plugin - Implementing Binary Plugins
• Using the Provider API - Configuring Tasks Lazily
• Using the configuration cache - Configuration cache
• Utility - Gradle Plugin Reference
• V - Glossary
• Variant attribute matching - Understanding Variant Selection
• Variant attribute matching algorithm - Understanding Variant Selection
• Variant attributes - Understanding Variant Selection
• Variant aware selection - The Java Plugin
• Variant selection errors - Understanding Variant Selection
• Variant-aware sharing of artifacts - How to share outputs between projects
• Verification failures - Advanced Tasks
• Verify the installation - Installing Gradle
• Verifying dependency checksums - Verifying dependencies
• Verifying dependency signatures - Verifying dependencies
• Verifying the integrity of the Gradle Wrapper JAR - Gradle Wrapper Reference
• Version Catalog - Dependency Management Basics
• Version Catalogs - Using Catalogs with Platforms
• Viewing Project Dependencies - Dependency Management Basics
• Viewing and debugging attributes - Variants and Attributes
• Viewing configurations - 2. Dependency Configurations
• Visual Studio Code - Gradle in IDEs
• Visual Studio IDE integration - Building native software
• Visualizing variant information - Understanding Variant Selection
• W - Glossary
• War - The War Plugin
• What is a build scan? - Inspecting Gradle Builds
• What to create - Build Init Plugin
• Which parts of metadata can be modified? - Modifying Dependency Metadata
• Why Gradle? - Gradle User Manual
• Why use the build cache? - Caching Android projects
• Windows Resources - Building native software
• Windows installation - Installing Gradle
• Worker API example - Developing Parallel Tasks
• Working with Gradle types - Gradle Kotlin DSL Primer
• Working with an imported build - Migrating Builds From Apache Ant
• Working with collections - Configuring Tasks Lazily
• Working with container objects - Gradle Kotlin DSL Primer
• Working with files - Configuring Tasks Lazily
• Working with files - Implementing Binary Plugins
• Working with files - Migrating Builds From Apache Ant
• Working with maps - Configuring Tasks Lazily
• Working with runtime properties - Gradle Kotlin DSL Primer
• Working with task inputs and outputs - Configuring Tasks Lazily
• Writing a component metadata rule - Modifying Dependency Metadata
• Writing an init script - Initialization Scripts
• Writing your own log messages - Logging
• X - Glossary
• Y - Glossary
• Z - Glossary
• macOS installation - Installing Gradle