Man Linux: Main Page and Category List


       0launch — download and run programs by URL


       0launch [OPTION]... INTERFACE [ARG]...

       0launch --list [SEARCH-TERM]

       0launch --import [FEED-FILES]


       0launch runs a program, identified by an ‘INTERFACE’. If the program is
       not already on your computer,  it  downloads  information  about  which
       versions  are  available,  and lets you choose one to download. It will
       also (automatically) do the same for libraries the program needs.

       0launch will also check for updates if it has been a  long  time  since
       the last check (configurable).

       Normally,  INTERFACE  is  taken as a FEED, which can be either a URL in
       the  form   ‘http://site/program’   or   a   local   path   name   like
       ‘/path/to/program.xml’.  For HTTP URLs, the remote file is a GPG-signed
       XML document. Local feed files are not signed. The  default  one-to-one
       mapping  from  interface  URIs  to  feed  URLs can be changed using the
       --feed option.


       When a program is available using 0launch, it will have  an  associated
       URL.  To  run  the  program,  simply  invoke  0launch  with  this as an


       The first time you do this, details about the  program  are  downloaded
       and cached, and you will be prompted to confirm the versions to use. In
       future,  the  program  will  run  directly  from  the   cache   without

       To check for new versions:

       0launch --refresh

       To search the list of cached URLs:

       0launch --list Edit

       To  avoid having to keep typing the full URI, use the 0alias(1) command
       to create shortcuts to run your programs.


              Chosen implementation’s version  number  must  be  earlier  than
              VERSION. i.e., force the use of an old version the program.

       -c, --console
              Never  use the GUI. Normally, 0launch switches to graphical mode
              if it needs  to  download  anything  from  the  network  (unless
              DISPLAY is not set).

       -d, --download-only
              Download  any needed files, but stop before actually running the

       -D, --dry-run
              Just print what actions would be taken.

       -f, --feed
              Register   (or   unregister)    an    additional    source    of
              implementations.  When  you  check  out a developer version of a
              project, it may contain an XML feed file. To add this version to
              the list of available versions, use --feed on this XML file. The
              file is not copied, so you don’t need to re-add  the  file  each
              time it is updated.

              Note  that  if  you just want to run the program, you can invoke
              0launch on the feed file directly (without using  --feed).  This
              will  force  the  injector to use that version, but won’t affect
              what happens when you run it using the URI as normal. Use --feed
              when  you  want to use the developer version even when using the
              URI, or if the program is a library (and thus referenced by  URI
              by other programs).

              Instead  of  running  the  program, just print the set of chosen
              implementations as an XML document to stdout. This can  be  used
              later  with  --set-selections.   Use  --select-only if you don’t
              even want to download the packages.

       -g, --gui
              Show the graphical policy editor.  This  allows  you  to  select
              which version of a program or library to use.

       -h, --help
              Show the built-in help text.

       -i, --import
              Import  from  files,  not  from the network. This is useful when
              testing a feed file, to avoid uploading it to a remote server in
              order  to  download  it  again.  It  might  also  be useful when
              installing from a CD or similar.  The file must have  a  trusted
              GPG  digital  signature,  as when fetching from the network. For
              unsigned interfaces, see --feed.

       -l, --list
              List all known interface (program) URIs. If  a  search  term  is
              given,   only  URIs  containing  that  string  are  shown  (case

       -m, --main=MAIN
              Run the specified executable instead of  the  default.  If  MAIN
              starts   with   ’/’   then   the   path   is   relative  to  the
              implementation’s top-level directory, whereas  otherwise  it  is
              relative  to  the directory containing the default MAIN program.
              For  example,  if  the  default  MAIN  is  bin/svn  then   using
              --main=svnadmin will run .../bin/svnadmin instead.

              Chosen  implementation’s version number must not be earlier than
              VERSION.  E.g., if you want to run version  2.0  or  later,  use

       -o, --offline
              Run  in  off-line  mode, overriding the default setting. In off-
              line mode, no interfaces are refreshed even if they are  out-of-
              date, and newer versions of programs won’t be downloaded even if
              the injector already knows about  them  (e.g.  from  a  previous

       -r, --refresh
              Fetch  a  fresh  copy of all used interfaces. This will normally
              switch to GUI mode, unless --console is also given.

              Download any required feeds and choose a set of implementations,
              but  don’t  actually  download  them.  If there are stale feeds,
              check for updates first (if we’re not off-line).

              Instead of choosing suitable implementations using  the  policy,
              run  exactly  the versions given in FILE. A suitable file can be
              created using the --get-selections option described above.

       -s, --source
              The implementation of the main (root)  interface  must  have  an
              architecture  of  the  form ’*-src’ (normally a literal "*", but
              could  be   a   compatible   OS).    Dependencies   are   normal
              implementations, not source ones. See 0compile for details.

       -v, --verbose
              More verbose output. Use twice for even more verbose output.

       -V, --version
              Display version information.

       -w, --wrapper=COMMAND
              Instead  of  executing  the chosen program directly, run COMMAND
              PROGRAM ARGS.  This is useful for running debuggers and  tracing
              tools  on  the  program (rather than on 0launch!). Note that the
              wrapper is executed in the environment selected by the  program;
              hence,  this  mechanism  cannot  be used for sandboxing. See the
              DEBUGGING section below.

              Append a directory to the list of implementation caches.


       To debug 0launch itself, use the --verbose and --console  options.  For

       $ 0launch -vvc http://myprog

       To  trace  or  debug programs run by 0launch, use the --wrapper option.
       For example, to run myprog --help, displaying all calls to open(2):

       $ 0launch --wrapper="strace -e open" http://myprog --help

       If your program is interpreted (e.g. a Python program), and you wish to
       debug the interpreter running it, you can do it like this:

       $ 0launch --wrapper="gdb --args python" http://myprog --help


       Configuration files (see basedir spec):

              Global configuration settings.

              List of trusted keys.

              Per-interface settings, and extra feeds.

       Cached data (can be re-downloaded if lost):

              Downloaded cached feed files.

              Downloaded cached implementations, indexed by manifest digest.

       See the 0store(1) man page for more information.


       Copyright (C) 2010 Thomas Leonard.

       You  may redistribute copies of this program under the terms of the GNU
       Lesser General Public License.


       Please report bugs to the developer mailing list:


       The Zero Install Injector was created by Thomas Leonard.


       0alias(1), 0store(1)

       The Zero Install web-site: