Gradle
User Manual
Theme
Community
Community Home
Community Forums
Community Plugins
Training
News
Newsletter
Blog
Twitter
Develocity
Github
Overview
What is Gradle?
The User Manual
Releases
All Releases
Release Notes
Installing Gradle
Upgrading Gradle
version 8.X to latest
version 7.X to 8.0
version 6.X to 7.0
version 5.X to 6.0
version 4.X to 5.0
Migrating to Gradle
from Maven
from Ant
Troubleshooting
Compatibility Notes
Gradle's Feature Lifecycle
Running Gradle Builds
Getting Started
Core Concepts
1. Gradle Basics
2. Gradle Wrapper Basics
3. Command-Line Interface Basics
4. Settings File Basics
5. Build File Basics
6. Dependency Management Basics
7. Task Basics
8. Plugins Basics
9. Incremental Builds + Caching
10. Build Scans
Tutorial
1. Initializing the Project
2. Running Tasks
3. Understanding Dependencies
4. Applying Plugins
5. Exploring Incremental Builds
6. Enabling the Build Cache
7. Using Reference Materials
Gradle in the IDE
Continuous Build
Authoring Gradle Builds
Getting Started
Learning the Basics
1. Gradle Directories
2. Multi-Project Builds
3. Gradle Build Lifecycle
4. Writing Settings Files
5. Writing Build Scripts
6. Using Tasks
7. Writing Tasks
8. Using Plugins
9. Writing Plugins
Tutorial
1. Initializing the Project
2. Understanding the Build Lifecycle
3. Multi-Project Builds
4. Writing the Settings File
5. Writing a Build Script
6. Writing Tasks
7. Writing Plugins
Structuring Builds
Structuring Projects with Gradle
Declaring Dependencies between Subprojects
Sharing Build Logic between Subprojects
Composite Builds
Configuration on Demand
Developing Tasks
Understanding Tasks
Controlling Task Execution
Organizing Tasks
Implementing Custom Tasks
Configuring Tasks Lazily
Developing Parallel Tasks
Developing Advanced Tasks
Developing Plugins
Understanding Plugins
Understanding Implementation Options
Implementing Pre-compiled Script Plugins
Implementing Binary Plugins
Testing Plugins
Publishing Plugins
Best Practices
Organizing Build Logic
Following Best Practices
Other Topics
Gradle-managed Directories
Working with Files
Working with Logging
Avoiding Traps
Configuring the Build Environment
Initialization Scripts
Writing Custom Gradle Types and Service Injection
Shared Build Services
Dataflow Actions
Testing a Build with TestKit
Using Ant from Gradle
Authoring JVM Builds
Building Java & JVM projects
Testing Java & JVM projects
Java Toolchains
Toolchains for JVM projects
Toolchain Resolver Plugins
Managing Dependencies
JVM Plugins
Java Library Plugin
Java Application Plugin
Java Platform Plugin
Groovy Plugin
Scala Plugin
Working with Dependencies
Terminology
Learning the Basics
What is Dependency Management?
Declaring Repositories
Declaring Dependencies
Understanding Library and Application Differences
Viewing and Debugging Dependencies
Understanding Resolution
Verifying dependencies
Declaring Versions
Declaring Versions and Ranges
Declaring Rich Versions
Handling Changing Versions
Locking Versions
Controlling Transitives
Upgrading Versions
Downgrading and Excluding
Sharing Versions
Aligning Dependencies
Handling Mutually Exclusive Dependencies
Fixing Metadata
Customizing Resolution
Preventing accidental upgrades
Producing and Consuming Variants of Libraries
Declaring Capabilities of a Library
Modeling Feature Variants and Optional Dependencies
Understanding Variant Selection
Declaring Variant Attributes
Sharing Outputs of Projects
Transforming Artifacts
Publishing Libraries
Setting up Publishing
Understanding Gradle Module Metadata
Signing Artifacts
Customizing Publishing
Maven Publish Plugin
Ivy Publish Plugin
Optimizing Build Performance
Improving Performance of Gradle Builds
Gradle Daemon
File System Watching
Incremental Build
Using the Build Cache
Enabling and Configuring
Why use the Build Cache?
Understanding the Impact
Learning Basic Concepts
Caching Java Project
Caching Android Project
Debugging Caching Issues
Troubleshooting
Using the Configuration Cache
Inspecting Gradle Builds
Configuring Gradle
Project Properties
Gradle Networking
Authoring C++/Swift Builds
Building C++ projects
Testing C++ projects
Building Swift projects
Testing Swift projects
Gradle on CI
Jenkins
TeamCity
GitHub Actions
Travis CI
Reference
Gradle DSLs and API
Javadoc
Groovy DSL Primer
Groovy DSL Reference
Kotlin DSL Primer
Kotlin DSL API
Groovy to Kotlin DSL Migration
Samples
Command-Line Interface
Gradle Wrapper
Core Plugins
Gradle & Third-party Tools
User Manual Single Page
User Manual PDF
Structuring Large Projects
version 8.7
This page has been removed. See
Multi-Project Builds
.
Was this page helpful?
Additional Feedback:
You can
submit issues
directly on Github.
Submit Feedback