ESET AV Remover (64-bit)

What's new in this version:

Performance improvements:
- File system watching is ready for production use
- In an incremental build, input and output files are checked to determine what needs to be rebuilt. This feature typically saves a lot of time; however, it adds some I/O overhead, which can be noticeable in large projects when not much has changed since the previous build.
- Back in Gradle 6.5 we've introduced file-system watching as an experimental feature. When enabled, it allows Gradle to keep what it has learned about the file system in memory during and between builds instead of polling the file system on each build. This significantly reduces the amount of disk I/O needed to determine what has changed since the previous build.
- This feature is now ready for production use and supported on Linux, Windows and macOS. You can enable it by adding the following to gradle.properties in the project root or in your Gradle user home: org.gradle.vfs.watch=true

Configuration cache improvements:
- Gradle 6.6 introduced configuration caching as an experimental feature. This release comes with usability and performance improvements for the configuration cache.
- Early adopters of configuration cache can use the command line output and HTML report for troubleshooting. Previously, the configuration cache state was saved despite reported problems, which in some situations required manual cache invalidation. In this release, the configuration cache gets discarded when the build fails because of configuration cache problems. Note that you can still ignore known problems.
- The problem report is also more helpful now. It reports the source of problems more accurately, pointing at the offending location in plugins and scripts in more cases.
- Loading from the configuration cache is also faster and memory consumption during builds has been reduced, especially for Kotlin and Android builds.
- Read about this feature and its impact on the Gradle blog. You can also track progress of configuration cache support in core plugins and community plugins.

New JVM ecosystem features:
- Toolchain support for JVM projects
- By default, Gradle uses the same Java version for running Gradle itself and building JVM projects.
- This is not always desirable. Building projects with different Java versions on different developer machines and CI servers may lead to unexpected issues. Additionally, you may want to build a project using a Java version that running Gradle is not compatible with.
- Before this release, it required several steps to configure a different Java version for compilation, testing, generating Javadoc, and executing applications.
- This release introduces the toolchain concept to simplify such a setup. A Java toolchain is a set of tools (javac compiler,java command etc), taken from a local Java installation and used during the build. Instead of manually specifying executables for the various tasks, toolchains provide a centralized place to define the Java version requirements in the build.

New dependency management features:
- Compile-only API dependencies for JVM libraries
- When writing a Java (or Groovy/Kotlin/Scala) library, there are cases where you require dependencies at compilation time which are parts of the API of your library, but which should not be on the runtime classpath.
- An example of such a dependency is an annotation library with annotations that are not used at runtime. These typically need to be available at compile time of the library's consumers when annotation processors inspect annotations of all classes. Another example is a dependency that is part of the runtime environment the library is expected to run on, but also provides types that are used in the public API of the library.
- The Java Library Plugin now offers the compileOnlyApi configuration for this purpose. It effectively combines the major properties of the compileOnly configuration (dependency will not be on the runtime classpath) and the api (dependencies are visible for consumers at compile time).

Other new features and usability improvements:
- Abbreviation of kebab-case project names
- Gradle allows you to abbreviate project and task names from the command-line. For example, you can execute the task compileTestJava by running gradle cTJ.
- Up until this release, fuzzy name matching only worked for camelCase names (e.g. compileTestJava). This is the recommended convention for task names, but it is unusual for project names. In the Java world, directory names are usually all lowercase by convention and in Gradle, project names usually follow the name of the directory the project is in.
- Many projects worked around this limitation by using kebab-case project directories (e.g. my-awesome-lib) while defining different camelCase project names in their settings scripts. This allowed them to use project name abbreviations in the command line but added additional complexity to the build.
- This release changes the fuzzy name matching to support for kebab-case names. Now, you can execute the compileTestJava task in the project my-awesome-lib with the following command

Fixed:
- Make <feature>RuntimeElements extend <feature>RuntimeOnly
- Only log file events that cause a change in the virtual file system
- Introduce file system watching debug flag
- Improve verbose VFS logging
- Update InProcessGradleExecuterIntegrationTest for file system watching
- Remove ToBeFixedForFileSystemWatching annotation
- Allow repository definition by configuration
- Add single/multi-project choice to 'gradle init --type application'
- Add 'compileOnlyApi' configuration to java-library projects
- TestNGTestFramework makes the Test Retry plugin incompatible with config cache
- Add switch to enable verbose logging for VFS
- Dependency resolution selector cache not specific enough for virtual platform edges
- Scala compilation of protobuf generated code is broken because zinc leaks protobuf-java to compile classpath
- Let user configure JavaCompile with source/target/release independant of a toolchain
- Performance bottleneck for large projects when file system watching is enabled
- Let `Javadoc` task accept a toolchain
- Remove incubating message about watching the file system
- Drop "unsafe" from file system watching-related property names
- Allow configuring the maximum number of watched hierarchies
- Change 'gradle init' to generate multi-projects
- Provide API to query for toolchains
- Extend name matching section in user guide
- RepositoryContentDescriptor should support include/exclude version ranges
- Verify project naming convention consistency
- Make use of kebab case name matching in gradle/gradle
- Precompiled script plugins - `GradleProperties has not been loaded yet.`
- Let `JavaExec` task accept a toolchain
- build events generated by tooling api are wrong when OperationCompletionListener is used
- Make fuzzy matching work with kebab-case project naming
- Use composition instead of inheritance to separate BuildOperationRunner from BuildOperatoinExecutor
- Configuration caching uses stale provider value
- Configuration caching querying task outputs too early
- Toolchain is matched deterministically
- Download toolchains on demand
- Use Kotlin source in Santa Tracker Kotlin Android performance tests
- Detect common Java installation locations
- Let `Test` task accept a toolchain
- Ability to configure toolchain requirements for a build
- Deprecate `JavaApplication#setMainClassName` in favour of property
- Enable partial VFS invalidation by default
- Move excessive logging around VFS to build operations
- Explain memory leak-like slowdown when FSW is enabled on Gradle build
- Support for compiling own (test) code with Groovy 4.0
- Gradle 6.5 pulls in optional dependency
- Gradle 6.5 build fails on Java 15-ea with Execution failed for task ':jar'. java.util.ConcurrentModificationException (no error message)
- Memory inefficiency in ConsumerVariantMatchResult for very large project.
- Pre-existing empty output directory may cause incorrect up-to-date checks
- JDK 15 support in Gradle
- Update integration tests using Jetty to run on JDK15
- Jacoco JDK15 support
- Review how TestKit directories are watched
- Disable file system watching when there is a change to Ant default excludes
- Verify correct usage of FileTimeStampInspector when file-system watching is enabled
- Use the Java API compiler when possible
- Attribute "without_test_code" is missing in .classpath file for project references
- Support `SUBST` or disable its use with file watching
- Test filters hide underlying issues during test task execution
- Add test for continuous build with VFS retention enabled
- Tooling API on JDK11 can not connect to Gradle project 4.5
- Feature? dependency lock missing skippedDependencies Property
- Composite artifact can't be resolved in buildSrc
- Maven2Gradle conversion support targeting Kotlin DSL
- Detect local Java installations
- Java toolchain detection should work on macos when no system VM installed
- Artifact transforms with dependencies fail when project substitutes external one
- Samples use nightly build instead of RC
- 6.7-rc-1: build fails with Cannot acquire state lock for project
- Property auto-detect used at configuration time when using toolchain with auto-download=false
- Service creation is too eager
- Javadoc and toolchain: task is up-to-date when toolchain changes
- `Problems reading data from Binary store` with intra-project dependency and capability resolution strategy
- Incremental annotation processing can fail when forking with Java 8
- Incremental compilation wipes out aggregating processor file in Gradle 6.7