- Documentation (2.5.3)- Release Notes
- Tutorials
- Reference- Introduction
- System Properties
- Settings Files
- Ivy Files
- Ant Tasks- artifactproperty
- artifactreport
- buildlist
- buildnumber
- buildobr
- cachefileset
- cachepath
- checkdepsupdate
- cleancache
- configure
- convertmanifest
- convertpom
- deliver
- dependencytree
- findrevision
- fixdeps
- info
- install
- listmodules
- makepom
- post resolve tasks
- publish
- report
- repreport
- resolve
- resources
- retrieve
- settings
- var
 
- Using standalone
- OSGi
 
- Developer doc
 
Using standalone
Ivy can be used as a standalone program very easily. All you need is a Java 7+ runtime environment (JRE)!
Then here is how to call it:
java -jar ivy.jar -?It will display usage text as follows:
usage: ivy
==== settings options
 -settings <settingsfile>     use given file for settings
 -properties <propertiesfile> use given file for properties not specified in set
                              tings
 -cache <cachedir>            use given directory for cache
 -novalidate                  do not validate ivy files against xsd
 -m2compatible                use Maven 2 compatibility
==== resolve options
 -ivy <ivyfile>               use given file as ivy file
 -refresh                     refresh dynamic resolved revisions
 -dependency <organisation> <module> <revision>
                              use this instead of ivy file to do the rest of the
                               work with this as a dependency.
 -confs <configurations>      resolve given configurations
 -types <types>               accepted artifact types
 -mode <resolvemode>          the resolve mode to use
 -notransitive                do not resolve dependencies transitively
==== retrieve options
 -retrieve <retrievepattern>  use given pattern as retrieve pattern
 -ivypattern <pattern>        use given pattern to copy the ivy files
 -sync                        use sync mode for retrieve
 -symlink                     create symbolic links
 -overwriteMode <overwriteMode> use given overwrite mode for retrieve
==== cache path options
 -cachepath <cachepathfile>   outputs a classpath consisting of all dependencies
                               in cache (including transitive ones) of the given
                               ivy file to the given cachepathfile
==== deliver options
 -deliverto <ivypattern>      use given pattern as resolved ivy file pattern
==== publish options
 -publish <resolvername>      use given resolver to publish to
 -publishpattern <artpattern> use given pattern to find artifacts to publish
 -revision <revision>         use given revision to publish the module
 -status <status>             use given status to publish the module
 -overwrite                   overwrite files in the repository if they exist
==== makepom options
 -makepom <pomfilepath>       create a POM file for the module
==== http auth options
 -realm <realm>               use given realm for HTTP AUTH
 -host <host>                 use given host for HTTP AUTH
 -username <username>         use given username for HTTP AUTH
 -passwd <passwd>             use given password for HTTP AUTH
==== launcher options
 -main <main>                 the FQCN of the main class to launch
 -args <args>                 the arguments to give to the launched process
 -cp <cp>                     extra classpath to use when launching process
==== message options
 -debug                       set message level to debug
 -verbose                     set message level to verbose
 -warn                        set message level to warn
 -error                       set message level to error
==== help options
 -?                           display this help
 -deprecated                  show deprecated options
 -version                     displays version information(since 1.3) System properties are included as Ivy variables, so you can easily define an Ivy variable like this:
java -Dmyivyvar=myvalue org.apache.ivy.Main [parameters](since 2.5) Additional properties defined in a separate .properties file (rather than Ivy settings) can be loaded using -properties option like this:
java -jar ivy.jar -properties version.properties -main org.apache.tools.ant.Main| Note | Prior to 2.5, Ivy -maincreated a classloader that used Ivy classloader as a parent. This is no longer the case; if your usage depended on Ivy classes being available, Ivy must be declared as a dependency of the component that you want to launch. | 
(since 2.5) Ivy can convert ivy.xml files to pom.xml files using -makepom option.
Examples
java -jar ivy.jarcalls Ivy with default configuration using ivy.xml in the current dir
java -jar ivy.jar -settings path/to/myivysettings.xml -ivy path/to/myivy.xmlcalls Ivy with given Ivy settings file using given Ivy file
(since 1.3)
java -jar ivy.jar -settings path/to/myivysettings.xml -dependency apache commons-lang 2.0calls Ivy with given Ivy settings file and resolve apache commons-lang 2.0.
This is equivalent to:
java -jar ivy.jar -settings path/to/myivysettings.xml -ivy ivy.xmlwith ivy.xml like this:
<ivy-module version="1.0">
  <info organisation="org"
       module="standalone"
       revision="working"/>
  <dependencies>
    <dependency org="apache" name="commons-lang" rev="2.0" conf="default->*"/>
  </dependencies>
</ivy-module>(since 1.3)
java -jar ivy.jar -settings path/to/myivysettings.xml -ivy path/to/myivy.xml -cachepath mycachefile.txtcalls Ivy with given Ivy settings file and resolves the dependencies found in the given Ivy file, and then outputs the classpath of resolved artifacts in cache in a file. This file can then be used to define a classpath corresponding to all the resolved dependencies for any Java program.
(since 1.4)
java -jar ivy.jar -settings path/to/myivysettings.xml -dependency bar foo 2.0 -main org.bar.foo.FooMaincalls Ivy with given Ivy settings file and resolves the dependency bar foo 2.0, and then runs org.foo.FooMain class with the resolved artifacts as classpath.
