anchor.diff:  If the build is being executed via the Tooling API, the build can be cancelled using the Tooling API's cancellation mechanism.
   
   [[continuous_build_limitations]]
  -=== Limitations and quirks
  -
  -There are several issues to be aware with the current implementation of continuous build.
  -These are likely to be addressed in future Gradle releases.
  +=== Limitations
  +
  +Under some circumstances continuous build will not detect changes to inputs.
  +
  +[[sec:continuous_build_missing_files]]
  +==== Adding new root input directories
  +
  +Sometimes, adding root input directories does not trigger a build, due to the way file system watching works.
  +For example, when adding the `src/main/java` directory, Gradle may not trigger a build.
  +Similarly, if the input is a <<working_with_files.adoc#filtering_files,filtered file tree>>, Gradle may not detect the addition of the first file matching the filter.
  +
  +[[sec:continuous_build_untracked]]
  +==== Inputs of untracked tasks
  +
  +Gradle will only watch for changes of inputs of tasks if it captures their state.
  +That means changes to the inputs of <<more_about_tasks.adoc#sec:disable-state-tracking,untracked tasks>> or tasks that have no outputs will not trigger a build.
  +
  +[[sec:continuous_build_project_dir]]
  +==== Changes to files outside of project directories
  +
  +Gradle only watches for changes to files inside the project directory.
  +Changes to files outside of the project directory will go undetected and not trigger a build.
   
   [[sec:build_cycles]]
   ==== Build cycles
  
positive.code: In some cases, it may be obvious (e.g., a Java file is compiled with `compileJava`).
  In other cases, you can use `--info` logging to find the task that is out-of-date due to the identified files.
  
  [[sec:continuous_build_limitations_jdk9]]
  ==== Restrictions with Java 9
  
  Due to class access restrictions related to Java 9, Gradle cannot set some operating system specific options, which means that:
  
  * On macOS, Gradle will poll for file changes every 10 seconds instead of every 2 seconds.
  * On Windows, Gradle must use individual file watches (like on Linux/Mac OS), which may cause continuous build to no longer work on very large projects.
  
  [[sec:performance_and_stability]]
  ==== Performance and stability
  
  The JDK file watching facility relies on inefficient file system polling on macOS (see: https://bugs.openjdk.java.net/browse/JDK-7133447[JDK-7133447]).
  This can significantly delay notification of changes on large projects with many source files.
  
  Additionally, the watching mechanism may deadlock under _heavy_ load on macOS (see: https://bugs.openjdk.java.net/browse/JDK-8079620[JDK-8079620]).
  This will manifest as Gradle appearing not to notice file changes.
  If you suspect this is occurring, exit continuous build and start again.
  
  On Linux, OpenJDK's implementation of the file watch service can sometimes miss file system events (see: https://bugs.openjdk.java.net/browse/JDK-8145981[JDK-8145981]).
  
  [[sec:changes_to_symbolic_links]]
  ==== Changes to symbolic links
  
   * Creating or removing symbolic link to files will initiate a build.
   * Modifying the target of a symbolic link will not cause a rebuild.
   * Creating or removing symbolic links to directories will not cause rebuilds.
   * Creating new files in the target directory of a symbolic link will not cause a rebuild.
   * Deleting the target directory will not cause a rebuild.
  
  [[sec:changes_to_build_logic_are_not_considered]]
  ==== Changes to build logic are not considered
  
negative.code: This means that unrelated changes (such as changes to build scripts) will not trigger a rebuild.
  In order 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.
  Especially, continuous build does not work when using `--no-daemon`.
  See <<gradle_daemon.adoc#sec:daemon_watch_fs,Watching the file system>> for more information.
  
  === Terminating Continuous Build
  
  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 `ENTER` or `RETURN` after `CTRL-D`).
  