# 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 `-main` created 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.jar
calls Ivy with default configuration using ivy.xml in the current dir
    java -jar ivy.jar -settings path/to/myivysettings.xml -ivy path/to/myivy.xml
calls 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.0
calls 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.xml
with `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.txt
calls 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.FooMain
calls 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.