Makes building Java projects very easy, and relative to other tools, such as Ant, Gradle is much easier to read.

It is also typically easy to get Gradle to agree with what you are trying to do, but can on occasion be fussy.

Having migrated from using plain old Ant files, using Gradle has made working with Java projects much easier than it was before. Adding thirdparty libraries, for instance, is much easier to do and understand. Review collected by and hosted on G2.com.

While Gradle is powerful and flexible, when there are issues they can be difficult to understand at first, and on more than one occasion I found it easier to just blow away a project and rebuild it again in a different directory, as it is typically easier to start fresh and not make mistakes than to fix made errors. Review collected by and hosted on G2.com.

I really liked that it was easy to learn gradle, and also easy to get up and running Review collected by and hosted on G2.com.

What I disliked was that whenever I had to troubleshoot build errors, the output from gradle was meaningless or ambiguous at best, it was rarely useful. Review collected by and hosted on G2.com.

Its the de-facto build system for Android. We use it everyday and its very useful since it can be installed on machine without Android studio and still compile apps.

There are a lot of plugins available which is the real stregth and it integrates with Maven too which makes it a better choice than Maven. Review collected by and hosted on G2.com.

It can get slow for large builds. As the size of the Android app grows, it tends to become slow. The main reason is that it uses Groovy instead of XML which makes it slow but leads to short scripts which is helpful. Review collected by and hosted on G2.com.

Gradle is the most powerful build tool ever.

On top of being powerful it is easy to make Gradle do what you want.

It is easy to understand by novices and they usually can't believe how simple it is.

The hallmark of a good model is that you are not surprised when you see the model in action. Gradle is the same way, Modelling a build is very intuitive. Review collected by and hosted on G2.com.

Gradle is moving faster than what most IDE projects can. There is a current gap in Eclipse because the original Gradle plugin is not being actively developed anymore and Eclipse Buildship is still behind and not supporting Eclipse WTP. Review collected by and hosted on G2.com.

Google is doing most of the Android build development in Gradle. ant is no more. maven is no more. At least one project has Google's backing. Review collected by and hosted on G2.com.

Slow and bulky. Even something as simple as "gradle clean" can take a minute. In an atypical Java fashion, its over-architected. Its DSL is unintuitive for Java developers. Review collected by and hosted on G2.com.

I like the ability to develop custom gradle tasks and the automatic integration with tools like intellij IDE. The gradle daemon was a nice addition too for speeding up build tasks. I also like the plugin feature where I can add specific features as needed. Review collected by and hosted on G2.com.

The first build of a project can take a long time as it downloads dependencies and libraries. Also being able to set the java version would be nice too. Documentation is a bit light, and am a bit confused about the various stages of the build cycle ( like whether a tasks is in setup or build ) Review collected by and hosted on G2.com.

I like Gradle for being an Open Source project that makes it really easy to manage native builds, unlike other tools like Ant and Maven, which are designed to work only with Java projects.

Gradle is very flexible. Also Gradle's code is much more readable that other solution's. Review collected by and hosted on G2.com.

At first it took me some time to get used to Gradle, but I wouldn't say it has a steep learning curve. Review collected by and hosted on G2.com.

Automation and integration of DevOPs toolchain. The build programming language is flexible and incisive. Short build times and uniform build scripts. Easy release process. Review collected by and hosted on G2.com.

Issues with Gradle and IDE integration with multiple modules. They are not present in multi-module mode. Review collected by and hosted on G2.com.

Gradle positions itself as a build tool somewhere between Ant (very explicit, simple, customizable, but difficult to optimize) and Maven (convention over configuration, not very customizable, but with neat optimization features like incremental and parallel builds).

Gradle provides all the power of Maven including integration with both Maven and Ivy repositories. It also allows integration with Ant (i.e. calling tasks from your Gradle build). It has a DSL that allows you to create your build *only* with configuration, but lets you customize it using Groovy where you need. This makes it a lot easier than Maven, which requires that you write a plugin (very few people ended up doing this in practise) or embed Ant scripts in your configuration.

There has been a lot of great work for improving performance, and the out-of-the-box plugin ecosystem is fantastic (lots of support for test tools, native compiler toolchains, Android, basically all the shiny new toys). Review collected by and hosted on G2.com.

Gradle is moving very quickly, and from release to release, it could well be that a feature you've come to depend on has been deprecated. It can be hard to keep up if you adopt now (even at 2.x, you're still a bit of an early adopter - they move quickly!)

If you're happy with Maven, then you will be very happy with Gradle since you likely don't have /too/ much customization in your build and you'll feel right at home. The conventions are similar, except programmatically inspecting your model is waaaay easier (ever tried fiddling with Maven profiles?)

If you're transitioning from Ant, there's a bit of a learning curve involved with writing your build scripts if you want best performance (you want to be declarative, not imperative, thus allowing the Gradle runtime to figure out possibly-more-optimal ways to do things). You can still write things imperatively if you really want - Gradle gives you some rope to hang yourself with - but you really shouldn't (hence the unfortunate learning curve). The incubating features like parallel/multithreaded builds and configure-on-demand are pretty useful for larger projects, and if you structure things correctly, your project will build very fast (if not, you can run the profile tool to figure out the slow steps).

One difficulty is transitioning some legacy projects to Gradle if there's been a lot of customization. It can be difficult to completely rewrite the builds for large monolithic builds, so it would be helpful to have a strategy for partially converting builds (i.e. invoke a Maven build from Gradle). It may already be possible to do this, I haven't looked too deeply. But in general it's a good strategy to transition parts of the build piece-by-piece.

Another challenge is the exception messages and errors can be hard to understand - though this should be improving with the new Managed Model system, which gives Gradle more insight into your build. Review collected by and hosted on G2.com.

Easy setup, the ability to automate production builds, making flavor, adding dependencies is very easy Review collected by and hosted on G2.com.

The long build time it takes when in online mode. Review collected by and hosted on G2.com.