What's the difference between implementation, api and compile in Gradle?

 

In Gradle, implementation, api, and compile are three different dependency configurations used to specify dependencies in your build.gradle file. These configurations have evolved over time in Gradle, and their usage has changed in different versions of Gradle.

Here's the difference between these configurations:

1. implementation:
   • Dependencies declared with implementation are only visible to the module (project) where they are declared. They are not exposed to other modules that depend on this module.
   • This configuration is recommended for most dependencies, as it helps in encapsulating the implementation details and reducing the risk of transitive dependency conflicts.
   • It's used when you want a dependency to be part of your module's internal implementation but not exposed to other modules.

Example:

gradle

dependencies {
    implementation 'com.example:my-library:1.0'
}

2. api:
   • Dependencies declared with api are visible to both the module where they are declared and any modules that depend on it.
   • Use this configuration when you want to expose a dependency to other modules that depend on your module.
   • It's less encapsulated and can lead to more significant transitive dependency conflicts if not used carefully.

Example:

gradle

dependencies {
    api 'com.example:shared-library:1.0'
}

3. compile (deprecated in Gradle 4.0+):
   • compile was used in older versions of Gradle (before version 4.0) to specify dependencies.
   • It was equivalent to api in that it exposed dependencies to other modules and was considered deprecated in favor of api and implementation.

Example (deprecated):

gradle

dependencies {
    compile 'com.example:legacy-library:1.0'
}

Please note that the usage of these configurations might have changed in newer versions of Gradle. Always refer to the official Gradle documentation and release notes for the most up-to-date information on dependency configurations.