Features

Ivy is a very powerful dependency manager oriented toward Java dependency management, even though it could be used to manage dependencies of any kind.

If you don't see why you should use a dependency manager at all, or have any question concerning Ivy in general, have a look at the FAQ and at the Mailing lists.

Integrated with Ant

Of course, Ivy is integrated with the most popular build management system for Java projects. But the integration goes way beyond common Ant integration. Indeed Ivy has been designed with Ant integration and design principles in mind. If you have Ant skills, you already have Ivy skills! The plugin mechanism in Ivy follows the same design as Ant, you will find macrodef and files import in Ivy configuration, many things Ant users are already familiar with.
And as Ivy is a sub project of Ant, we even share the same development community!

Simple to use

For simple cases, Ivy is easy to use. Declare your dependencies, and that's all. See the quick start tutorial to check yourself, it should take less than 5 minutes!

Ivy can therefore be used to bring the dependency management feature of maven to Ant build files, for those of you who already use Ant and who do not want to setup a maven project. But Ivy does not stop there, it provides many more great features!

Clean dependency reports

Ivy is able to produce mainly two kind of reports: HTML reports and graph reports. HTML reports gives you a good understanding of what Ivy did, and which dependencies your project depends upon. The graph reports let you have a good overview of the transitive dependencies (see below) and conflicts in your project.

Here are some samples of what Ivy generates for you:

Non intrusive

Ivy most common use is to resolve dependencies and copy them in the lib dir of your project. Once copied, your build does not depend on Ivy any more. Thus you can easily migrate existing builds using the lib dir pattern to store dependencies. Moreover, you can easily deliver your project with its dependencies so that the build file does not depend on Ivy.

Extremely flexible

With Ivy, you usually do not have to adapt your project to Ivy structure, Ivy will conform to your environment.

Even though Ivy comes with a lots of default values to work out of the box, you can change many things in Ivy. Of course, the dependencies repositories possibilities covers a lot of uses (file system, URL based, repository chaining, ...). But that's not all. You can change the way Ivy finds latest versions of your dependencies, you can change of conflict manager, you can choose if you want Ivy to copy dependencies in your project libs or use them directly from Ivy cache, ...

Easily extensible

When Ivy does not do what you want out of the box, you can often extend it to solve your problem. For instance, you can plug your own repository. But you can also define your own latest strategy and your own conflict manager. See how to extend Ivy in the reference doc.

Moreover you can even define very easily your own metadata on your modules, with extra attributes.

High performances

In Ivy, performances have been taken in consideration from the beginning. It uses a cache to avoid downloading twice a dependency, its strong conflict management system has been thought to avoid downloading a dependency if not necessary, all settings and Ivy files parsing are done using SAX for maximum performance, and so on...

Transitive dependencies

Imagine you have a component that you often reuse in your software development. Imagine that this component has dependencies as well. Then without a good dependency management tool, each time you use this component in your software you have to declare it as a dependency, but also all its dependencies.

With Ivy it's different: you simply write a dependency file once for the component, declaring its own dependencies, then anytime you want to use this component you simply have to declare a dependency on it.

And this is even more powerful if the component your software depends on changes of dependencies during its own development. Then, without Ivy, you have to maintain all your components dependencies declaration each time the dependencies of this component change. With Ivy, you update the Ivy file of the component and that's it !

Strong conflict management

The problem with transitive dependencies is that it's sometimes difficult to know exactly which version of a dependency you get, because several modules are depending on it in different versions. Ivy provides a strong and flexible conflict management engine, which let you easily choose which version should be evicted or kept if its default behavior does not fit your needs.

It is also fully integrated with transitive dependencies management, which means that conflicts are solved for each dependency before being solved for your whole module. This ensures that problematic conflicts will only need to solved in the dependency they are encountered.

Out of the box maven repository support

The public maven repository has many advantages: a lot of modules available, easy search with mvnrepository.com, ... With Ivy, you benefit from this repository out of the box thanks to maven 2 metadata compatibility.

Continuous Integration Ready

Are you working in a continuous integration environment? No? You should ;-)

If you are working in a continuous integration environment, and if you have many projects that depend one on each other, then you are maybe experiencing the dependency management nightmare... Fortunately, Ivy is there to help !

With Ivy you can declare that a component depends on the latest version of another component. Knowing that, Ivy will search for the latest version of the dependency whenever you ask it to do so. This latest version is computed by Ivy either by checking the date of the dependency versions or by comparing versions as text (either lexicographically or with an algorithm close to the one used in php version_compare function).

Publication handling

Ivy handles for you the publication of your projects to your repository, as defined in Ivy. This simplifies a lot the management of multi-project environment.

Pluggable module descriptor parsers

Ivy is able to use Ivy files as module descriptors, but also maven2 POMs, or even your own module descriptors! This can help you move softly from an existing repository of modules to an Ivy managed one.

Unique enterprise features

Ivy is the only dependency management tool to support powerful features such as repository namespace and building through the install task. A tutorial is dedicated to this feature, and show you how you can build your own repository importing data from public one, and converting heterogeneous repositories into a stable and homogeneous one.

Heavily tested

Ivy benefits from a lot of unit tests checked at each code modification. It is also under heavy testing by the community itself, and we pay a lot of attention to bug fixing and code stability.

Free and open source

Ivy is an Apache project, which means that it's fully open sourced, with a business friendly Apache license.

Being open source, you can even modify it for your own needs, and let the community benefit from your enhancements if you like.

Extensively documented

With Ivy, not only the tool is free and open source, but you also have access to a very detailed documentation including tutorials and reference documentation, all for free!

Self contained

The core Ivy engine which allows to perform most of Ivy features is provided as a single jar with no dependency at all, except on JRE 1.4 or greater. This means that you can very easily use Ivy to bootstrap your build system, or embedded in your own tool. Ant support itself is provided only as a thin wrapper over Ivy engine so that you can do everything in embedded or standalone mode