'How to find/remove unused dependencies in Gradle

I wanted to find unused dependencies in my project. Is there a feature for this in Gradle, like in Maven?

Solution 1:^[1]

UPDATE for Kotlin Users: 17 December 2021: Detects missing or superfluous build dependencies in Kotlin projects : Version 1.0.9 (latest)

I have added 2 types of configuration for Kotlin users.

Using the plugins DSL
Using legacy plugin application

Using the plugins DSL:

plugins {
  id("com.faire.gradle.analyze") version "1.0.9"
}

Using legacy plugin application:

buildscript {
  repositories {
    maven {
      url = uri("https://plugins.gradle.org/m2/")
    }
  }
  dependencies {
    classpath("com.faire.gradle:gradle-kotlin-buildozer:1.0.9")
  }
}

apply(plugin = "com.faire.gradle.analyze")

Resource Link:

UPDATE: 28-06-2016: Android support to unused-dependency

In June, 2017, they have released the 4.0.0 version and renamed the root project name "gradle-lint-plugin" to "nebula-lint-plugin". They have also added Android support to unused-dependency.

In May 2016 Gradle has implemented the Gradle lint plugin for finding and removing unwanted dependency

Gradle Lint Plugin: Full Documentation

The Gradle Lint plugin is a pluggable and configurable linter tool for identifying and reporting on patterns of misuse or deprecations in Gradle scripts and related files.

This plugin has various rules. Unused Dependency Rule is one of them. It has three specific characteristics.

Removes unused dependencies.
Promotes transitive dependencies that are used directly by your code to explicit first order dependencies.
Relocates dependencies to the 'correct' configuration.

To apply the rule, add:

gradleLint.rules += 'unused-dependency'

Details of Unused Dependency Rule is given in the last part.

To apply the Gradle lint plugin:

buildscript { repositories { jcenter() } }
plugins {
  id 'nebula.lint' version '0.30.2'
}

Alternatively:

buildscript {
  repositories { jcenter() }
  dependencies {
    classpath 'com.netflix.nebula:gradle-lint-plugin:latest.release'
  }
}

apply plugin: 'nebula.lint'

Define which rules you would like to lint against:

gradleLint.rules = ['all-dependency'] // Add as many rules here as you'd like

For an enterprise build, we recommend defining the lint rules in a init.gradle script or in a Gradle script that is included via the Gradle apply from mechanism.

For multimodule projects, we recommend applying the plugin in an allprojects block:

allprojects {
  apply plugin: 'nebula.lint'
  gradleLint.rules = ['all-dependency'] // Add as many rules here as you'd like
}

Details of Unused Dependency Rule is given in this part

To apply the rule, add:

gradleLint.rules += 'unused-dependency'

The rule inspects compiled binaries emanating from your project's source sets looking for class references and matches those references to the dependencies that you have declared in your dependencies block.

Specifically, the rule makes the following adjustments to dependencies:

1. Removes unused dependencies

Family-style jars like com.amazonaws:aws-java-sdk are removed, as they don't contain any code

2. Promotes transitive dependencies that are used directly by your code to explicit first order dependencies

This has the side effect of breaking up family style JAR files, like com.amazonaws:aws-java-sdk, into the parts that you are actually using, and adding those as first order dependencies

3. Relocates dependencies to the 'correct' configuration

Webjars are moved to the runtime configuration
JAR files that don't contain any classes and content outside of META-INF are moved to runtime
'xerces', 'xercesImpl', 'xml-apis' should always be runtime scoped
Service providers (JAR files containing META-INF/services) like mysql-connector-java are moved to runtime if there isn't any provable compile-time reference
Dependencies are moved to the highest source set configuration possible. For example, 'junit' is relocated to testCompile unless there is an explicit dependency on it in the main source set (rare).

UPDATE: Previous plugins

For your kind information, I want to share about previous plugins

The Gradle plugin that finds unused dependencies, declared and transitive is com.github.nullstress.dependency-analysis

But its latest version 1.0.3 is created 23 December 2014. After that there aren't any updates.

N.B: Many of our engineers are being confused about this plugin as they updated only the version number, nothing else.

Solution 2:^[2]

I just learned about this one: https://plugins.gradle.org/plugin/com.autonomousapps.dependency-analysis

Github

From the looks it is under active development, but I haven't tested it yet.

Edit: Actually its pretty awesome, it provides lots of advises (e.g. whether to use api vs implementation)

Solution 3:^[3]

The project mentioned in the earlier answers seem to be dead. I use gradle-dependency-analyze. Setup is simple:

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath 'ca.cutterslade.gradle:gradle-dependency-analyze:1.0.3'
  }
}

apply plugin: 'ca.cutterslade.analyze'

Then do:

$ gradle analyzeDependencies

Solution 4:^[4]

I've had a lot of luck using the Gradle Dependency Analysis Plugin. To get started with it, add the following two things to your Gradle build script.

buildscript {
    repositories {
        maven {
            url "https://plugins.gradle.org/m2/"
        }
    }
    dependencies {
        classpath "com.github.nullstress:DependencyAnalysisPlugin:1.0.3"
    }
}

and

apply plugin: "dependencyAnalysis"

Once those are in place, run gradle analyze. If there are unused dependencies, you'll get a build failure that shows output similar to the text below, plus a list of the unused dependencies (both declared and transitive). The build failure is really handy if you want to enforce that there should be no unused dependencies via a CI build.

:foo:analyze FAILED

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':foo:analyze'.
> The project has unused declared artifacts

Solution 5:^[5]

Editor's Note: This answer is out of date. Please see the top answer.

You can try the com.github.nullstress.dependency-analysis Gradle plugin

Build script snippet for use in all Gradle versions:

buildscript {
  repositories {
    jcenter()
  }
  dependencies {
    classpath "com.github.nullstress:DependencyAnalysisPlugin:1.0.3"
  }
}

apply plugin: "com.github.nullstress.dependency-analysis"

Build script snippet for new, incubating, plugin mechanism introduced in Gradle 2.1:

plugins {
  id "com.github.nullstress.dependency-analysis" version "1.0.3"
}

Also, there is a thread (Is there a Gradle equivalent of "mvn dependency:analyze"?) in the Gradle forum about this.

Solution 6:^[6]

The projects on most of the historical answers are dead, but gradle-dependency-analyze appears to be alive as of 2016-05-30.

Sources

This article follows the attribution requirements of Stack Overflow and is licensed under CC BY-SA 3.0.

Source: Stack Overflow

Solution	Source
Solution 1
Solution 2
Solution 3	Subhash Chandran
Solution 4
Solution 5	Peter Mortensen
Solution 6	Peter Mortensen