Gradle
User Manual
  • 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
  • Compatibility 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
  • 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
  • Other Topics
    • Gradle managed Directories
    • Working with Files
    • Working with Logging
    • Avoiding Traps
    • Configuring the Build Environment
    • Initialization Scripts
  • Structuring Individual Builds
    • Creating a Basic Multi-Project Build
    • Declaring Dependencies between Subprojects
    • Sharing Build Logic between Subprojects
    • Fine Tuning the Project Layout
    • Understanding Configuration and Execution
  • Structuring Software Products
    • Structuring Large Projects
    • Tweaking Project Structure
    • Composing Builds
  • Authoring Sustainable Builds
    • Organizing Build Logic
    • Following Best Practices
  • Developing Gradle Tasks
    • Authoring Tasks
    • Writing Gradle Task Types
    • Configuring Tasks Lazily
    • Avoiding Unnecessary Task Configuration
    • Developing Parallel Tasks
  • Developing Gradle Plugins
    • Starting Plugin Development
    • Designing Plugins
    • Implementing Plugins
    • Testing Plugins
    • Publishing Plugins
  • Other Developing Gradle Topics
    • 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 PDF
Docs
  • User Manual
  • DSL Reference
  • Release Notes
  • Javadoc
News
  • Blog
  • Newsletter
  • Twitter
  • Status Page
Products
  • Build Scan™
  • Build Cache
  • Develocity Docs
Get Help
  • Forums
  • GitHub
  • Training
  • Services
Stay UP-TO-DATE on new features and news

By entering your email, you agree to our Terms and Privacy Policy, including receipt of emails. You can unsubscribe at any time.

© Gradle Inc. 2023 All rights reserved.
gradle
Careers | Privacy | Terms of Service | Contact