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
--continuous command-line option.
For example, you can continuously run the
test task and all dependent tasks by running:
$ gradle test --continuous
Gradle will behave as if you ran
gradle test after a change to sources or tests that contribute to the requested tasks.
This means unrelated changes (such as changes to build scripts) will not trigger a rebuild.
To incorporate build logic changes, the continuous build must be restarted manually.
Continuous build uses file system watching to detect changes to the inputs.
If file system watching does not work on your system, then continuous build won’t work either.
In particular, continuous build does not work when using
When Gradle detects a change to the inputs, it will not trigger the build immediately.
Instead, it will wait until no additional changes are detected for a certain period of time - the quiet period.
You can configure the quiet period in milliseconds by the Gradle property
If Gradle is attached to an interactive input source, such as a terminal, the continuous build can be exited by pressing
CTRL-D (On Microsoft Windows, it is required to also press
If Gradle is not attached to an interactive input source (e.g. is running as part of a script), the build process must be terminated (e.g. using the
kill command or similar).
If the build is being executed via the Tooling API, the build can be cancelled using the Tooling API’s cancellation mechanism.
Under some circumstances, continuous build may not detect changes to inputs.
Sometimes, creating an input directory that was previously missing does not trigger a build, due to the way file system watching works.
For example, creating the
src/main/java directory may not trigger a build.
Similarly, if the input is a filtered file tree and no files are matching the filter, the creation of matching files may not trigger a build.
Changes to the inputs of untracked tasks or tasks that have no outputs may not trigger a build.
Gradle only watches for changes to files inside the project directory. Changes to files outside the project directory will go undetected and not trigger a build.
Gradle starts watching for changes just before a task executes. If a task modifies its own inputs while executing, Gradle will detect the change and trigger a new build. If every time the task executes, the inputs are modified again, the build will be triggered again. This isn’t unique to continuous build. A task that modifies its own inputs will never be considered up-to-date when run "normally" without continuous build.
If your build enters a build cycle like this, you can track down the task by looking at the list of files reported changed by Gradle.
After identifying the file(s) that are changed during each build, you should look for a task that has that file as an input.
In some cases, it may be obvious (e.g., a Java file is compiled with
In other cases, you can use
--info logging to find the task that is out-of-date due to the identified files.