// Copyright (C) 2024 Gradle, Inc.
//
// Licensed under the Creative Commons Attribution-Noncommercial-ShareAlike 4.0 International License.;
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      https://creativecommons.org/licenses/by-nc-sa/4.0/
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

[[command_line_interface]]
= Command-Line Interface
:keywords: cli, clean, check, projects, tasks, rerun-tasks, continue, build-cache, no-build-cache, configuration-cache, no-configuration-cache, configuration-cache-problems, configure-on-demand, no-configure-on-demand, max-workers, parallel, no-parallel, priority, profile, scan, watch-fs, no-watch-fs, help, version, show-version, full-stacktrace, stacktrace, org.gradle.debug, org.gradle.debug.host, org.gradle.debug.port, org.gradle.debug.server, org.gradle.debug.suspend, project-cache-dir, system-prop, init-script, project-prop, org.gradle.jvmargs, org.gradle.java.home, gradle-user-home, dependency-verification, write-verification-metadata, refresh-keys, export-keys, include-build, offline, refresh-dependencies, dry-run, continuous, write-locks, update-locks , no-rebuild, org.gradle.warning.mode, warning-mode, no-problems-report, problems-report, org.gradle.console, console, org.gradle.logging.level, quiet, warn, info, debug, daemon, no-daemon, foreground, status, stop, org.gradle.daemon.idletimeout, exclude-task, distribution-type, gradle-distribution-url, gradle-distribution-sha256-sum, gradle-version

The command-line interface is the **primary method of interacting with Gradle**.

The following is a reference for executing and customizing the Gradle command-line.
It also serves as a reference when writing scripts or configuring continuous integration.

**Use of the <<gradle_wrapper.adoc#gradle_wrapper, Gradle Wrapper>> is highly encouraged**.
Substitute `./gradlew` (in macOS / Linux) or `gradlew.bat` (in Windows) for `gradle` in the following examples.

Executing Gradle on the command-line conforms to the following structure:

[source,text]
----
gradle [taskName...] [--option-name...]
----

Options are allowed _before_ and _after_ task names.

[source,text]
----
gradle [--option-name...] [taskName...]
----

If multiple tasks are specified, you should separate them with a space.

[source,text]
----
gradle [taskName1 taskName2...] [--option-name...]
----

Options that accept values can be specified with or without `=` between the option and argument. The use of `=` is recommended.

[source,text]
----
gradle [...] --console=plain
----

Options that enable behavior have long-form options with inverses specified with `--no-`. The following are opposites.

[source,text]
----
gradle [...] --build-cache
gradle [...] --no-build-cache
----

Many long-form options have short-option equivalents. The following are equivalent:

[source,text]
----
gradle --help
gradle -h
----

NOTE: Many command-line flags can be specified in `gradle.properties` to avoid needing to be typed.
See the <<build_environment.adoc#sec:gradle_configuration_properties, Configuring build environment guide>> for details.

[[sec:command_line_usage]]
== Command-line usage

The following sections describe the use of the Gradle command-line interface.

Some plugins also add their own command line options.
For example, `--tests`, which is added by <<java_testing.adoc#test_filtering,Java test filtering>>.
For more information on exposing command line options for your own tasks, see <<custom_tasks.adoc#sec:declaring_and_using_command_line_options,Declaring command-line options>>.

[[sec:command_line_executing_tasks]]
=== Executing tasks

You can learn about what projects and tasks are available in the <<#sec:command_line_project_reporting, project reporting section>>.

Most builds support a common set of tasks known as <<organizing_tasks.adoc#sec:lifecycle_tasks,_lifecycle tasks_>>. These include the `build`, `assemble`, and `check` tasks.

To execute a task called `myTask` on the root project, type:

[source,bash]
----
$ gradle :myTask
----

This will run the single `myTask` and all of its <<writing_tasks_intermediate.adoc#sec:task_dependencies,dependencies>>.

[[sec:disambiguate_task_options_from_built_in_options]]
=== Specify options for tasks

To pass an option to a task, prefix the option name with `--` after the task name:

[source,bash]
----
$ gradle :exampleTask --exampleOption=exampleValue
----

[[disambiguate_conflicting_task_options]]
==== Disambiguate task options from built-in options

Gradle does not prevent tasks from registering options that conflict with Gradle's built-in options, like `--profile` or `--help`.

You can fix conflicting task options from Gradle's built-in options with a `--` delimiter before the task name in the command:

[source,bash]
----
$ gradle [--built-in-option-name...] -- [taskName...] [--task-option-name...]
----

Consider a task named `mytask` that accepts an option named `profile`:

- In `gradle mytask --profile`, Gradle accepts `--profile` as the built-in Gradle option.

- In `gradle \-- mytask --profile=value`, Gradle passes `--profile` as a task option.

[[executing_tasks_in_multi_project_builds]]
=== Executing tasks in multi-project builds

In a <<multi_project_builds_intermediate.adoc#intro_multi_project_builds, multi-project build>>, subproject tasks can be executed with `:` separating the subproject name and task name.
The following are equivalent when _run from the root project_:

[source,bash]
----
$ gradle :subproject:taskName
----

[source,text]
----
$ gradle subproject:taskName
----

You can also run a task for _all_ subprojects using a task _selector_ that consists of only the task name.

The following command runs the `test` task for all subprojects when invoked from the _root project directory_:

[source,bash]
----
$ gradle test
----

To recap:

[source,text]
----
// Run a task in the root project only
$ gradle :exampleTask --exampleOption=exampleValue

// Run a task that may exist in the root or any subproject (ambiguous if defined in more than one)
$ gradle exampleTask --exampleOption=exampleValue

// Run a task in a specific subproject
$ gradle subproject:exampleTask --exampleOption=exampleValue
$ gradle :subproject:exampleTask --exampleOption=exampleValue
----

NOTE: Some tasks selectors, like `help` or `dependencies`, will only run the task on the project they are invoked on and not on all the subprojects.

When invoking Gradle from within a subproject, the project name should be omitted:

[source,bash]
----
$ cd subproject
----

[source,bash]
----
$ gradle taskName
----

TIP: When executing the Gradle Wrapper from a subproject directory, reference `gradlew` relatively. For example: `../gradlew taskName`.

[[executing_multiple_tasks]]
=== Executing multiple tasks

You can also specify multiple tasks.
The tasks' dependencies determine the precise order of execution, and a task having no dependencies may execute earlier than it is listed on the command-line.

For example, the following will execute the `test` and `deploy` tasks in the order that they are listed on the command-line and will also execute the dependencies for each task.

[source,bash]
----
$ gradle test deploy
----

[[command_line_order_safety]]
=== Command line order safety

Although Gradle will always attempt to execute the build quickly, command line ordering safety will also be honored.

For example, the following will
execute `clean` and `build` along with their dependencies:

[source,bash]
----
$ ./gradlew clean build
----

However, the intention implied in the command line order is that `clean` should run first and then `build`. It would be incorrect to execute `clean` _after_ `build`, even if doing so would cause the build to execute faster since `clean` would remove what `build` created.

Conversely, if the command line order was `build` followed by `clean`, it would not be correct to execute `clean` before `build`. Although Gradle will execute the build as quickly as possible, it will also respect the safety of the order of tasks specified on the command line and ensure that `clean` runs before `build` when specified in that order.

Note that <<incremental_build.adoc#incremental_build,command line order safety>> relies on tasks properly declaring what they create, consume, or remove.

[[sec:excluding_tasks_from_the_command_line]]
=== Excluding tasks from execution

You can exclude a task from being executed using the `-x` or `--exclude-task` command-line option and providing the name of the task to exclude:

[source,bash]
----
$ gradle dist --exclude-task test
----
[source,text]
----
include::{snippetsPath}/reference/runtime-configuration/excludeTasks/tests/excludeTask.out[]
----

image::commandLineTutorialTasks.png[]

You can see that the `test` task is not executed, even though the `dist` task depends on it.
The `test` task’s dependencies, such as `compileTest`, are not executed either.
The dependencies of `test` that other tasks depend on, such as `compile`, are still executed.

[[sec:rerun_tasks]]
=== Forcing tasks to execute

You can force Gradle to execute all tasks ignoring <<incremental_build.adoc#incremental_build,up-to-date checks>> using the `--rerun-tasks` option:

[source,bash]
----
$ ./gradlew test --rerun-tasks
----

This will force `test` and _all_ task dependencies of `test` to execute. It is similar to running `gradle clean test`, but without the build's generated output being deleted.

Alternatively, you can tell Gradle to rerun a specific task using the `--rerun` built-in <<#sec:task_options, task option>>.

[[sec:continue_build_on_failure]]
=== Continue the build after a task failure

By default, Gradle aborts execution and fails the build when any task fails.
This allows the build to complete sooner and prevents cascading failures from obfuscating the root cause of an error.

You can use the `--continue` option to force Gradle to execute every task when a failure occurs:

[source,bash]
----
$ ./gradlew test --continue
----

When executed with `--continue`, Gradle executes _every_ task in the build if all the dependencies for that task are completed without failure.

For example, tests do not run if there is a compilation error in the code under test because the `test` task depends on the `compilation` task.
Gradle outputs each of the encountered failures at the end of the build.

NOTE: If any tests fail, many test suites fail the entire `test` task.
Code coverage and reporting tools frequently run after the test task, so "fail fast" behavior may halt execution before those tools run.

[[sec:name_abbreviation]]
=== Name abbreviation

When you specify tasks on the command-line, you don't have to provide the full name of the task.
You can provide enough of the task name to identify the task uniquely.
For example, it is likely `gradle che` is enough for Gradle to identify the `check` task.

The same applies to project names. You can execute the `check` task in the `library` subproject with the `gradle lib:che` command.

You can use https://en.wikipedia.org/wiki/Camel_case[camel case] patterns for more complex abbreviations. These patterns are expanded to match camel case and https://en.wikipedia.org/wiki/Kebab_case[kebab case] names.
For example, the pattern `foBa` (or `fB`) matches `fooBar` and `foo-bar`.

More concretely, you can run the `compileTest` task in the `my-awesome-library` subproject with the command `gradle mAL:cT`.

[source,bash]
----
$ ./gradlew mAL:cT
----
[source,text]
----
include::{snippetsPath}/reference/runtime-configuration/nameMatching/tests/nameMatching.out[]
----

Abbreviations can also be used with the `-x` command-line option.

[[tracing_name_expansion]]
=== Tracing name expansion

For complex projects, it might be ambiguous if the intended tasks were executed. When using abbreviated names, a single typo can lead to the execution of unexpected tasks.

When `INFO`, or more <<logging.adoc#logLevels,verbose logging>> is enabled, the output will contain extra information about the project and task name expansion.

For example, when executing the `mAL:cT` command on the previous example, the following log messages will be visible:

[source,text]
----
No exact project with name ':mAL' has been found. Checking for abbreviated names.
Found exactly one project that matches the abbreviated name ':mAL': ':my-awesome-library'.
No exact task with name ':cT' has been found. Checking for abbreviated names.
Found exactly one task name, that matches the abbreviated name ':cT': ':compileTest'.
----

[[sec:common_tasks]]
== Common tasks

The following are task conventions applied by built-in and most major Gradle plugins.

[[computing_all_outputs]]
=== Computing all outputs

It is common in Gradle builds for the `build` task to designate assembling all outputs and running all checks:

[source,bash]
----
$ ./gradlew build
----

[[running_applications]]
=== Running applications

It is common for applications to run with the `run` task, which assembles the application and executes some script or binary:

[source,bash]
----
$ ./gradlew run
----

[[running_all_checks]]
=== Running all checks

It is common for _all_ verification tasks, including tests and linting, to be executed using the `check` task:

[source,bash]
----
$ ./gradlew check
----

[[cleaning_outputs]]
=== Cleaning outputs

You can delete the contents of the build directory using the `clean` task. Doing so will cause pre-computed outputs to be lost, causing significant additional build time for the subsequent task execution:

[source,bash]
----
$ ./gradlew clean
----

[[sec:command_line_project_reporting]]
== Project reporting

Gradle provides several built-in tasks which show particular details of your build.
This can be useful for understanding your build's structure and dependencies, as well as debugging problems.

[[listing_projects]]
=== Listing projects

Running the `projects` task gives you a list of the subprojects of the selected project, displayed in a hierarchy:

[source,bash]
----
$ ./gradlew projects
----

You also get a project report with https://scans.gradle.com/[Build Scan].

[[sec:listing_tasks]]
=== Listing tasks

Running `gradle tasks` gives you a list of the main tasks of the selected project. This report shows the default tasks for the project, if any, and a description for each task:

[source,bash]
----
$ ./gradlew tasks
----

By default, this report shows only those tasks assigned to a task group.

Groups (such as verification, publishing, help, build...) are available as the header of each section when listing tasks:

[source,text]
----
> Task :tasks

Build tasks
-----------
assemble - Assembles the outputs of this project.

Build Setup tasks
-----------------
init - Initializes a new Gradle build.

Distribution tasks
------------------
assembleDist - Assembles the main distributions

Documentation tasks
-------------------
javadoc - Generates Javadoc API documentation for the main source code.
----

You can obtain more information in the task listing using the `--all` option:

[source,bash]
----
$ ./gradlew tasks --all
----

The option `--no-all` can limit the report to tasks assigned to a task group.

If you need to be more precise, you can display only the tasks from a specific group using the `--group` option:

[source,bash]
----
$ ./gradlew tasks --group="build setup"
----

You can use the `--provenance` option to show where each task was registered (e.g., by a plugin or build script):

[source,bash]
----
$ ./gradlew tasks --provenance
----
[source,text]
----
Build tasks
-----------
assemble - Assembles the outputs of this project. (registered by plugin 'org.gradle.language.base.plugins.LifecycleBasePlugin')
build - Assembles and tests this project. (registered by plugin 'org.gradle.language.base.plugins.LifecycleBasePlugin')
----

[[sec:show_task_details]]
=== Show task usage details

Running `gradle help --task someTask` gives you detailed information about a specific task:

[source,bash]
----
$ ./gradlew -q help --task libs
----
[source,text]
----
include::{snippetsPath}/reference/runtime-configuration/projectReports/tests/taskHelp.out[]
----

This information includes the full task path, the task type, possible <<sec:task_options,task-specific command line options>>, and the description of the given task.
The output also includes provenance information showing where the task was registered (e.g., in a build file or by a plugin).

You can get detailed information about the task class types using the `--types` option or using `--no-types` to hide this information.

[[reporting_dependencies]]
=== Reporting dependencies

https://scans.gradle.com/[Build Scan] gives a full, visual report of what dependencies exist on which configurations, transitive dependencies, and dependency version selection.
They can be invoked using the `--scan` options:

[source,bash]
----
$ ./gradlew myTask --scan
----

This will give you a link to a web-based report, where you can find <<viewing_debugging_dependencies.adoc#sec:debugging-build-scans,dependency information>> like this:

image::gradle-core-test-build-scan-dependencies.png[Build Scan dependencies report]

[[sec:listing_project_dependencies]]
=== Listing project dependencies

Running the `dependencies` task gives you a list of the dependencies of the selected project, broken down by configuration. For each configuration, the direct and transitive dependencies of that configuration are shown in a tree.

Below is an example of this report:

[source,bash]
----
$ ./gradlew dependencies
----
[source,text]
----
> Task :app:dependencies

------------------------------------------------------------
Project ':app'
------------------------------------------------------------

compileClasspath - Compile classpath for source set 'main'.
+--- project :model
|    \--- org.json:json:20220924
+--- com.google.inject:guice:5.1.0
|    +--- javax.inject:javax.inject:1
|    +--- aopalliance:aopalliance:1.0
|    \--- com.google.guava:guava:30.1-jre -> 28.2-jre
|         +--- com.google.guava:failureaccess:1.0.1
|         +--- com.google.guava:listenablefuture:9999.0-empty-to-avoid-conflict-with-guava
|         +--- com.google.code.findbugs:jsr305:3.0.2
|         +--- org.checkerframework:checker-qual:2.10.0 -> 3.28.0
|         +--- com.google.errorprone:error_prone_annotations:2.3.4
|         \--- com.google.j2objc:j2objc-annotations:1.3
+--- com.google.inject:guice:{strictly 5.1.0} -> 5.1.0 (c)
+--- org.json:json:{strictly 20220924} -> 20220924 (c)
+--- javax.inject:javax.inject:{strictly 1} -> 1 (c)
+--- aopalliance:aopalliance:{strictly 1.0} -> 1.0 (c)
+--- com.google.guava:guava:{strictly [28.0-jre, 28.5-jre]} -> 28.2-jre (c)
+--- com.google.guava:guava:{strictly 28.2-jre} -> 28.2-jre (c)
+--- com.google.guava:failureaccess:{strictly 1.0.1} -> 1.0.1 (c)
+--- com.google.guava:listenablefuture:{strictly 9999.0-empty-to-avoid-conflict-with-guava} -> 9999.0-empty-to-avoid-conflict-with-guava (c)
+--- com.google.code.findbugs:jsr305:{strictly 3.0.2} -> 3.0.2 (c)
+--- org.checkerframework:checker-qual:{strictly 3.28.0} -> 3.28.0 (c)
+--- com.google.errorprone:error_prone_annotations:{strictly 2.3.4} -> 2.3.4 (c)
\--- com.google.j2objc:j2objc-annotations:{strictly 1.3} -> 1.3 (c)
----
Concrete examples of build scripts and output available in <<viewing_debugging_dependencies.adoc#sec:debugging-build-scans,Viewing and debugging dependencies>>.

Running the `buildEnvironment` task visualises the buildscript dependencies of the selected project, similarly to how `gradle dependencies` visualizes the dependencies of the software being built:

[source,bash]
----
$ ./gradlew buildEnvironment
----

Running the `dependencyInsight` task gives you an insight into a particular dependency (or dependencies) that match specified input:

[source,bash]
----
$ ./gradlew dependencyInsight --dependency [...] --configuration [...]
----

The `--configuration` parameter restricts the report to a particular configuration such as `compileClasspath`.

[[sec:listing_properties]]
=== Listing project properties

Running the `properties` task gives you a list of the properties of the selected project:

[source,bash]
----
$ ./gradlew -q api:properties
----
[source,text]
----
include::{snippetsPath}/reference/runtime-configuration/projectReports/tests/propertyListReport.out[]
----

You can also query a single property with the optional `--property` argument:

[source,bash]
----
$ ./gradlew -q api:properties --property allprojects
----
[source,text]
----
include::{snippetsPath}/reference/runtime-configuration/projectReports/tests/propertyReport.out[]
----

[[sec:command_line_completion]]
== Command-line completion

Gradle provides `bash` and `zsh` tab completion support for tasks, options, and Gradle properties through https://github.com/gradle/gradle-completion[gradle-completion] (installed separately):

image::gradle-completion-4.0.gif[]

[[sec:command_line_debugging]]
== Debugging options

`-?`, `-h`, `--help`::
Shows a help message with the built-in CLI options organized into logical sections.
To show project-contextual options, including help on a specific task, see the `help` task.

`-v`, `--version`::
Prints Gradle, Groovy, Ant, Launcher & Daemon JVM, and operating system version information and exit without executing any tasks.

`-V`, `--show-version`::
Prints Gradle, Groovy, Ant, Launcher & Daemon JVM, and operating system version information and continue execution of specified tasks.

`-S`, `--full-stacktrace`::
Print out the full (very verbose) stacktrace for any exceptions. See also <<#sec:command_line_logging, logging options>>.

`-s`, `--stacktrace`::
Print out the stacktrace also for user exceptions (e.g. compile error). See also <<#sec:command_line_logging, logging options>>.

`--scan`::
Create a https://gradle.com/develocity/product/build-scan[Build Scan] with fine-grained information about all aspects of your Gradle build.

`-Dorg.gradle.debug=true`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that debugs the <<gradle_daemon.adoc#gradle_daemon, Gradle Daemon>> process. Gradle will wait for you to attach a debugger at `localhost:5005` by default.

`-Dorg.gradle.debug.host=(host address)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that specifies the host address to listen on or connect to when debug is enabled.
In the server mode on Java 9 and above, passing `*` for the host will make the server listen on all network interfaces.
By default, no host address is passed to JDWP, so on Java 9 and above, the loopback address is used, while earlier versions listen on all interfaces.

`-Dorg.gradle.debug.port=(port number)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that specifies the port number to listen on when debug is enabled. _Default is `5005`._

`-Dorg.gradle.debug.server=(true,false)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that if set to `true` and debugging is enabled, will cause Gradle to run the build with the socket-attach mode of the debugger. Otherwise, the socket-listen mode is used. _Default is `true`._

`-Dorg.gradle.debug.suspend=(true,false)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that if set to `true` and debugging is enabled, the JVM running Gradle will suspend until a debugger is attached. _Default is `true`._

[[sec:command_line_performance]]
== Performance options

Try these options when optimizing and <<performance.adoc#performance_gradle,improving>> build performance.

Many of these options can be <<build_environment.adoc#sec:gradle_configuration_properties,specified>> in the `gradle.properties` file, so command-line flags are unnecessary.

`--build-cache`, `--no-build-cache`::
Toggles the <<build_cache.adoc#build_cache, Gradle Build Cache>>. Gradle will try to reuse outputs from previous builds. _Default is off_.

`--configuration-cache`, `--no-configuration-cache`::
Toggles the <<configuration_cache.adoc#config_cache,Configuration Cache>>. Gradle will try to reuse the build configuration from previous builds. _Default is off_.

`--configuration-cache-problems=(fail,warn)`::
Configures how the configuration cache handles problems. Default is `fail`.
+
Set to `warn` to report problems without failing the build.
+
Set to `fail` to report problems and fail the build if there are any problems.

`--configure-on-demand`, `--no-configure-on-demand` incubating-label:[]::
Toggles configure-on-demand. Only relevant projects are configured in this build run. _Default is off_.

`--isolated-projects`, `--no-isolated-projects` incubating-label:[]::
Toggles <<isolated_projects.adoc#isolated_projects,Isolated Projects>>. Projects are configured in parallel. Implies `--configuration-cache`. _Default is off_.

`--max-workers`::
Sets the maximum number of workers that Gradle may use. _Default is number of processors_.

`--parallel`, `--no-parallel`::
Build projects in parallel. For limitations of this option, see <<performance.adoc#sec:enable_parallel_execution, Parallel Project Execution>>. _Default is off_.

`--priority`::
Specifies the scheduling priority for the Gradle daemon and all processes launched by it. Values are `normal` or `low`. _Default is normal_.

`--profile`::
Generates a high-level performance report in the `layout.buildDirectory.dir("reports/profile")` directory. `--scan` is preferred.

`--scan`::
Generate a Build Scan with detailed performance diagnostics.

image::gradle-core-test-build-scan-performance.png[Build Scan performance report]

`--watch-fs`, `--no-watch-fs`::
Toggles <<file_system_watching.adoc#sec:daemon_watch_fs,watching the file system>>.
When enabled, Gradle reuses information it collects about the file system between builds.
_Enabled by default on operating systems where Gradle supports this feature._

[[gradle_daemon_options]]
=== Gradle daemon options

You can manage the <<gradle_daemon.adoc#gradle_daemon,Gradle Daemon>> through the following command line options.

`--daemon`, `--no-daemon`::
Use the <<gradle_daemon.adoc#gradle_daemon, Gradle Daemon>> to run the build. Starts the daemon if not running or the existing daemon is busy. _Default is on_.

`--foreground`::
Starts the Gradle Daemon in a foreground process.

`--status` (Standalone command)::
Run `gradle --status` to list running and recently stopped Gradle daemons. It only displays daemons of the same Gradle version.

`--stop` (Standalone command)::
Run `gradle --stop` to stop all Gradle Daemons of the same version.

`-Dorg.gradle.daemon.idletimeout=(number of milliseconds)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> wherein the Gradle Daemon will stop itself after this number of milliseconds of idle time. _Default is 10800000_ (3 hours).

[[sec:command_line_logging]]
== Logging options

[[setting_log_level]]
=== Setting log level

You can customize the <<logging.adoc#logging,verbosity>> of Gradle logging with the following options, ordered from least verbose to most verbose.

`-Dorg.gradle.logging.level=(quiet,warn,lifecycle,info,debug)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that sets the logging level.

`-q`, `--quiet`::
Log errors only.

`-w`, `--warn`::
Set log level to warn.

`-i`, `--info`::
Set log level to info.

`-d`, `--debug`::
Log in debug mode (includes normal stacktrace).

_Lifecycle_ is the default log level.

[[sec:command_line_customizing_log_format]]
=== Customizing log format

You can control the use of rich output (colors and font variants) by specifying the console mode in the following ways:

`-Dorg.gradle.console=(auto,plain,colored,rich,verbose)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that specifies the console mode. Different modes are described immediately below.

`--console=(auto,plain,colored,rich,verbose)`::
Specifies which type of console output to generate.
+
Set to `plain` to generate plain text only. This option disables all color and other rich output in the console output. This is the default when Gradle is _not_ attached to a terminal.
+
Set to `colored` to generate colored output without rich status information such as progress bars.
+
Set to `auto` (the default) to enable color and other rich output in the console output when the build process is attached to a console or to generate plain text only when not attached to a console. _This is the default when Gradle is attached to a terminal._
+
Set to `rich` to enable color and other rich output in the console output, regardless of whether the build process is not attached to a console. When not attached to a console, the build output will use ANSI control characters to generate the rich output.
+
Set to `verbose` to enable color and other rich output like `rich` with output task names and outcomes at the lifecycle log level, (as is done by default in Gradle 3.5 and earlier).
+
NOTE: When the `NO_COLOR` environment variable is set and non-empty, Gradle suppresses color output regardless of the console mode.
Bold, underline, and rich features like progress bars are unaffected.
See link:https://no-color.org/[no-color.org].

[[sec:command_line_problems]]
=== Reporting problems

`--problems-report` (enabled by default) incubating-label:[]::
Enable the generation of `build/reports/problems-report.html`.
This is the default behaviour.
The report is generated with problems provided to the <<reporting_problems.adoc#sec:reporting_problems,Problems API>>.

`--no-problems-report` incubating-label:[]::
Disable the generation of `build/reports/problems-report.html`, by default this report is generated with problems provided to the <<reporting_problems.adoc#sec:reporting_problems,Problems API>>.

[[sec:command_line_warnings]]
=== Showing or hiding warnings

By default, Gradle won't display all warnings (e.g. deprecation warnings). Instead, Gradle will collect them and render a summary at the end of the build like:

[source,text]
----
Deprecated Gradle features were used in this build, making it incompatible with Gradle 5.0.
----

You can control the verbosity of warnings on the console with the following options:

`-Dorg.gradle.warning.mode=(all,fail,none,summary)`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that specifies the warning mode. Different modes are described immediately below.

`--warning-mode=(all,fail,none,summary)`::
Specifies how to log warnings. Default is `summary`.
+
Set to `all` to log all warnings.
+
Set to `fail` to log all warnings and fail the build if there are any warnings.
+
Set to `summary` to suppress all warnings and log a summary at the end of the build.
+
Set to `none` to suppress all warnings, including the summary at the end of the build.

[[sec:rich_console]]
=== Rich console

Gradle's rich console displays extra information while builds are running.

image::rich-cli.png[alt="Gradle Rich Console"]

Features:

* Progress bar and timer visually describe the overall status
* Parallel work-in-progress lines below describe what is happening now
* Colors and fonts are used to highlight significant output and errors

[[sec:command_line_execution_options]]
== Execution options

The following options affect how builds are executed by changing what is built or how dependencies are resolved.

`--include-build`::
Run the build as a <<composite_builds.adoc#composite_builds,composite>>, including the specified build.

`--offline`::
Specifies that the build should operate <<dependency_caching.adoc#sec:controlling-dependency-caching-command-line,without accessing network resources>>.

`-U`, `--refresh-dependencies`::
Refresh the <<dependency_caching.adoc#sec:controlling-dependency-caching-command-line,state of dependencies>>.

`--continue`::
<<command_line_interface.adoc#sec:continue_build_on_failure,Continue task execution>> after a task failure.

`-m`, `--dry-run`::
Run Gradle with all task actions disabled. Use this to show which task would have executed.

`--task-graph` since-gradle-label:9.1.0[]::
Run Gradle with all task actions disabled and print the task dependency graph.

`-t`, `--continuous`::
Enables <<#sec:continuous_build,continuous build>>. Gradle does not exit and will re-execute tasks when task file inputs change.

`--write-locks`::
Indicates that all resolved configurations that are _lockable_ should have their <<dependency_locking.adoc#locking-versions,lock state>> persisted.

`--update-locks <group:name>[,<group:name>]*`::
Indicates that versions for the specified modules have to be updated in the <<dependency_locking.adoc#locking-versions,lock file>>.
+
This flag also implies `--write-locks`.

`-a`, `--no-rebuild`::
Do not rebuild project dependencies.
Useful for <<sharing_build_logic_between_subprojects.adoc#sec:using_buildsrc, debugging and fine-tuning `buildSrc`>>, but can lead to wrong results. Use with caution!

[[sec:dependency_verification_options]]
== Dependency verification options

Learn more about this in <<dependency_verification.adoc#verifying-dependencies,dependency verification>>.

`-F=(strict,lenient,off)`, `--dependency-verification=(strict,lenient,off)`::
Configures the <<dependency_verification.adoc#sec:disabling-verification,dependency verification mode>>.
+
The default mode is `strict`.

`-M`, `--write-verification-metadata`::
Generates checksums for dependencies used in the project (comma-separated list) for <<dependency_verification.adoc#sec:bootstrapping-verification,dependency verification>>.

`--refresh-keys`::
Refresh the public keys used for dependency verification.

`--export-keys`::
Exports the public keys used for dependency verification.

[[sec:environment_options]]
== Environment options

You can <<build_environment.adoc#build_environment,customize>> many aspects of build scripts, settings, caches, and so on through the options below.

`-g`, `--gradle-user-home`::
Specifies the Gradle User Home directory. The default is the `.gradle` directory in the user's home directory.

`-p`, `--project-dir`::
Specifies the start directory for Gradle. Defaults to current directory.

`--project-cache-dir`::
Specifies the project-specific cache directory. Default value is `.gradle` in the root project directory.

`-D`, `--system-prop`::
Sets a <<build_environment.adoc#sec:gradle_system_properties,system property>> of the JVM, for example `-Dmyprop=myvalue`.

`-I`, `--init-script`::
Specifies an <<init_scripts.adoc#init_scripts,initialization script>>.

`-P`, `--project-prop`::
Sets a <<build_environment.adoc#sec:project_properties,project property>> of the root project, for example `-Pmyprop=myvalue`.

`-Dorg.gradle.jvmargs`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that sets JVM arguments.

`-Dorg.gradle.java.home`::
A <<build_environment.adoc#sec:gradle_configuration_properties,Gradle property>> that sets the JDK home dir.

[[sec:non_interactive]]
== Non-interactive mode

By default, Gradle may prompt the user for input on the console when an interactive terminal is available.
You can disable all interactive prompting by using the `--non-interactive` command-line option.

In non-interactive mode, Gradle uses default values instead of prompting.
This is useful for running Gradle in automated environments such as CI pipelines, scripts, and AI agents.

`--non-interactive`::
Do not prompt for user input.

[[sec:task_options]]
== Task options

Tasks may define task-specific options which are different from most of the global options described in the sections above (which are interpreted by Gradle itself, can appear anywhere in the command line, and can be listed using the `--help` option).

Task options:

1. Are consumed and interpreted by the tasks themselves;
2. *Must* be specified immediately after the task in the command-line;
3. May be listed using `gradle help --task someTask` (see <<#sec:show_task_details, Show task usage details>>).

To learn how to declare command-line options for your own tasks, see <<custom_tasks.adoc#sec:declaring_and_using_command_line_options,Declaring and Using Command Line Options>>.

[[sec:builtin_task_options]]
=== Built-in task options

Built-in task options are options available as task options for all tasks. At this time, the following built-in task options exist:

`--rerun`::
Causes the task to be rerun even if up-to-date. Similar to `<<#sec:rerun_tasks,--rerun-tasks>>`, but for a specific task.

[[sec:command_line_bootstrapping_projects]]
== Bootstrapping new projects

[[creating_new_gradle_builds]]
=== Creating new Gradle builds

Use the built-in `gradle init` task to create a new Gradle build, with new or existing projects.

[source,bash]
----
$ gradle init
----

Most of the time, a project type is specified.
Available types include `basic` (default), `java-library`, `java-application`, and more.
See <<build_init_plugin.adoc#build_init_plugin, init plugin documentation>> for details.

[source,bash]
----
$ gradle init --type java-library
----

[[standardize_and_provision_gradle]]
=== Standardize and provision Gradle

The built-in `gradle :wrapper` task generates a script, `gradlew`, that invokes a declared version of Gradle, downloading it beforehand if necessary.

[source,bash]
----
$ ./gradlew :wrapper --gradle-version=8.1
----

You can also specify `--distribution-type=(bin|all)`, `--gradle-distribution-url`, `--gradle-distribution-sha256-sum` in addition to `--gradle-version`. +
Full details on using these options are documented in the <<gradle_wrapper.adoc#gradle_wrapper,Gradle wrapper section>>.

[[sec:continuous_build]]
== Continuous build

Continuous Build allows you to automatically re-execute the requested tasks when file inputs change.
You can execute the build in this mode using the `-t` or `--continuous` command-line option.

Learn more in <<continuous_builds.adoc#continuous_builds,Continuous Builds>>.
