# Antigen β
[](http://travis-ci.org/zsh-users/antigen)
Antigen is a small set of functions that help you easily manage your shell (zsh)
plugins, called bundles. The concept is pretty much the same as bundles in a
typical vim+pathogen setup. Antigen is to zsh, what [Vundle][] is to vim.
Please note that this is a very new project and can be considered beta at best.
That said, I am using antigen full time now on my work machine.
Note: Please read the commit comments of the changesets when you pull a new
version of antigen.
## Show off
> Enough talk. Let's fight!
> -- Po, Kung-fu Panda.
You're going to experience antigen right in your open shell. No `.zshrc`
tweaking and reading the rest of this documentation. Kinda like an ice-cream
sample, if you will.
Get and load antigen.
curl https://raw.github.com/zsh-users/antigen/master/antigen.zsh > antigen.zsh
source antigen.zsh
There. You now have all the antigen goodies. Let's try install some plugins. How
about some color to start with. Get the [syntax highlighting plugin][] by
running
antigen-bundle zsh-users/zsh-syntax-highlighting
Now let it do its thing and once you're back at your prompt, try and type a
command. See that? Colors!
So, you do git? ruby? git and ruby? There are lots of awesome plugins over at
oh-my-zsh. Treat yourself to some.
antigen-bundle robbyrussell/oh-my-zsh plugins/ruby
# Or for the lazy,
antigen-bundle git
There are lots of plugins out there in the wild and people are writing zsh
utilities as small scripts all the time. Antigen is compatible with all of them.
The plugins and scripts don't need any special handling to be compatible with
antigen.
Another example, [kennethreitz's autoenv][autoenv]. Just a bundle command away.
antigen-bundle kennethreitz/autoenv
And boom! you have all the autoenv goodness. Just remember how you used to do
these before antigen, clone it, modify your bashrc to source it, load a new
terminal, all just to test it out. Duh!
A subtle aspect of this is that you can tell antigen to grab just about anything
from anyone's `dotfiles` repo, as long as it is in a directory under any repo on
github.
And themes? How would you like a fancy new prompt for yourself?
antigen-theme funky
No? Not your taste? There are many themes available to you, check out the
oh-my-zsh's [page on themes][].
You can install themes from unofficial repos too!
antigen-theme XsErG/zsh-themes themes/lazyuser
See? It's easy!
To see how that works, refer to the section on antigen-theme further down.
Note: Many of those plugins and especially themes, assume you have the core
library of oh-my-zsh loaded. So, if you want to experiment further, issue a
antigen-lib
and continue until you're tired. At which point you can come back to this page
;)
## Usage
So, now that you're here, I suppose you are convinced and want antigen running
your shell all the time. Sweet. Let's do it.
First, clone this repo, probably as a submodule if you have your dotfiles in a
git repo,
git clone https://github.com/zsh-users/antigen.git
The usage should be very familiar to you if you use Vundle. A typical `.zshrc`
might look like this
source /path-to-antigen-clone/antigen.zsh
# Load the oh-my-zsh's library.
antigen-lib
# Bundles from the default repo (robbyrussell's oh-my-zsh).
antigen-bundle git
antigen-bundle heroku
antigen-bundle pip
antigen-bundle lein
antigen-bundle command-not-found
# Syntax highlighting bundle.
antigen-bundle zsh-users/zsh-syntax-highlighting
# Load the theme.
antigen-theme robbyrussell
# Tell antigen that you're done.
antigen-apply
Open your zsh with this zshrc and you should see all the bundles you defined
here, getting installed. Once its done, you are ready to roll. The complete
syntax for the `antigen-bundle` command is discussed further down on this page.
## Motivation
If you use zsh and [oh-my-zsh][], you know that having many different plugins
that are developed by many different authors in a single (sub)repo is not very
easy to maintain. There are some really fantastic plugins and utilities in
oh-my-zsh, but having them all in a single repo doesn't really scale well. And I
admire robbyrussell's efforts for reviewing and merging the gigantic number of
pull requests the project gets. We need a better way of plugin management.
This was discussed on [a][1] [few][2] [issues][3], but it doesn't look like
there was any progress made. So, I'm trying to start this off with antigen,
hoping to better this situation. Please note that I'm by no means a zsh or any
shell script expert (far from it).
[1]: https://github.com/robbyrussell/oh-my-zsh/issues/465
[2]: https://github.com/robbyrussell/oh-my-zsh/issues/377
[3]: https://github.com/robbyrussell/oh-my-zsh/issues/1014
Inspired by vundle, antigen can pull oh-my-zsh style plugins from various github
repositories. You are not limited to use plugins from the oh-my-zsh repository
only and you don't need to maintain your own fork and pull from upstream every
now and then. I actually encourage you to grab plugins and scripts from various
sources, straight from the authors, before they even submit it to oh-my-zsh as a
pull request.
Antigen also lets you switch the prompt theme with one command, just like that
bundle-theme candy
and your prompt is changed, just for this session of course (unless you put this
line in your `.zshrc`).
## Commands
The following are the commands provided by antigen. Note that the `-` in the
following commands can be replaced with a space. You can write `antigen-bundle
...` as `antigen bundle ...` and get away with it. For more details see the help
on `antigen` command further down in this section.
### antigen-bundle
This command tells antigen to install (if not already installed) and load the
given plugin. The simplest usage follows the following syntax.
antigen-bundle
This will install and load the `plugins/` directory from [robbyrussell's
oh-my-zsh][oh-my-zsh] (can be changed by setting `ANTIGEN_DEFAULT_REPO_URL`).
However, the above is just syntax sugar for the extended syntax of the
`antigen-bundle` command.
antigen-bundle [ []]
where `` is the repository url and it defaults to [robbyrussell's
oh-my-zsh][oh-my-zsh] repo (can be changed by setting `ANTIGEN_DEFAULT_REPO_URL`
discussed further down). `` is the path under this repository which has the
zsh plugin. This is typically the directory that contains a `*.plugin.zsh` file,
but it could contain a completion file or just many `*.zsh` files to be sourced.
`` defaults to `/`, which indicates the repository itself is a plugin.
An example invocation would be
# The following is the same as `antigen-bundle ant`. But for demonstration
# purposes, we use the extended syntax here.
antigen-bundle https://github.com/robbyrussell/oh-my-zsh.git plugins/ant
This would install the ant plugin from robbyrussell's oh-my-zsh repo. Of course,
github url's can be shortened.
antigen-bundle robbyrussell/oh-my-zsh plugins/ant
And since this repo is the default, even that isn't necessary. But we can't
specify the `loc` without giving the first argument.
For this and a few other reasons, `antigen-bundle` also supports a simple
keyword argument syntax, using which we can rewrite the above as
antigen-bundle --loc=plugins/ant
Which picks up the default for the `url` argument, and uses the `loc` given to
it.
*Note* that you can mix and match positional and keyword arguments. But you
can't have positional arguments after keyword arguments.
antigen-bundle robbyrussell/oh-my-zsh --loc=plugins/ant
And keyword arguments don't care about the order in which the arguments are
specified. The following is perfectly valid.
antigen-bundle --loc=plugins/ant --url=robbyrussell/oh-my-zsh
You can also specify a local directory on your file system as a bundle. In this
case, make sure the path you give is the absolute path (i.e., starts with a
`/`). Relative paths are not supported. If the repo you gave is a local
directory path, then it is not necessary that this path is a git repo. Please
refer to the notes on `--no-local-clone` below.
This command can also be used from your shell environment. This allows you to
install plugins on the fly and try them out. Of course if you want a bundle to
be available every time you open a shell, put it in your `.zshrc`.
Other keyword-only arguments accepted:
`--branch={git-branch-name}` — Specify the branch of the git repo to be
used for this bundle (without the braces of course). The default is whatever
branch the clone comes with, which is usually `master`. For example,
antigen-bundle github-user/repo --branch=develop
This will get the plugin as in the branch `develop`.
Note that if you specify two plugins to be loaded from the same git repo, but
different branches, then two separate clones of this repo will be maintained.
This is a small implementation detail and shouldn't influence you in any way.
`--no-local-clone` — This command can be useful if you are developing a
plugin and already have a clone on your local file system. If this argument is
not given, even if the given repo url is a local path, a clone is made in the
`$ADOTDIR/repos`, and the plugin is loaded from that clone. But, if you give
this argument, the plugin is sourced straight from the repo location, without
creating a clone. For example,
antigen-bundle /absolute/path/to/the/plugin --no-local-clone
Note that if the repo url is *not* an absolute local path or a branch has been
specified with the `--branch` option, this argument has no effect. That is,
for this option to have any affect, the repo url must be an absolute local path
and no `--branch` should be specified.
Also, if the local path given as the url is not a git repo, then this
argument is forced as it doesn't makes sense to *clone* something that's not a
git repo. This property can be used to load any utility scripts you have in your
dotfiles repo. For example,
antigen-bundle $HOME/dotfiles/oh-my-zsh/custom
In addition to the above discussed arguments, `antigen-bundle` also takes a
`btype` keyword-only argument, that is used internally. You shouldn't be
concerned with this argument, its only used internally and will probably go away
in the future. It indicates whether the bundle is a theme or a simple plugin.
### antigen-bundles
If you have a fair number of bundles, using the `antigen-bundle` command can
look cumbersome. You can use the `antigen-bundles` command to *bulk* define
bundles instead of individual calls to `antigen-bundle`.
Usage is pretty straightforward. Just pipe the bundle specifications, just as
you would give to the `antigen-bundle` command, one per line, into the
`antigen-bundles` command. The easiest way to do this, is using the heredoc
syntax.
antigen-bundles <α
Reverts the state of all your plugins to how they were before the last
`antigen-update`. This command is currently experimental, so don't rely too much
on it. There is a test for it, and it passes, so it should work fine though.
Takes no options.
Insider detail: The information for reverting is stored in
`$ADOTDIR/revert-info` file. If its not present, reverting is not possible.
### antigen-list
Use this command to list out the currently *loaded* plugins. Keep in mind that
this includes any bundles installed on-the-fly.
Takes no arguments. Gives out four entries per line of output, denoting the
following fields of each bundle.
The `btype` field is an internal detail, that specifies if the bundle is a
`plugin` or a `theme`.
The final field is `true` or `false` reflecting whether there is a local clone
for this bundle.
### antigen-cleanup
Used to clean up the clones of repos which are not used by any plugins currently
loaded. It takes no arguments. When run, it lists out the repo-clones that are
available but are not used by any plugin *currently loaded*.
This command, by default asks for confirmation before deleting the unused
clones. If the `--force` argument is given, then this confirmation is not asked.
It straight away deletes all the unused clones. This option makes this command
usable in a non-interactive fashion.
### antigen-lib
This is a shortcut to
antigen-bundle --loc=lib
So, it basically installs the oh-my-zsh's library as a bundle.
Please note that this assumes that the `ANTIGEN_DEFAULT_REPO_URL` is set to the
oh-my-zsh repo or a fork of that repo. If you want to specify the `url` too,
then you can't use the `antigen-lib` short cut. You have to do that directly
with the `antigen-bundle` command.
This is present only for legacy reasons and *might* (or might not) be removed in
the future.
Use
antigen-lib
in your `.zshrc`, before any `antigen-bundle` declarations. It takes no
arguments.
### antigen-theme
Used for switching the prompt theme. Invoke it with the name of the theme you
want to use.
antigen-theme fox
Currently, themes are pulled from robbyrussell's oh-my-zsh repo, but it will
support getting themes from other repos as well in the future.
You can use this command to change your theme on the fly in your shell. Go on,
try out a few themes in your shell before you set it in your `.zshrc`.
**Note**: Some themes use functions that are loaded by `antigen-lib`. So, to
avoid any trouble, run `antigen-lib` if you haven't already before experimenting
with themes. If you have `antigen-lib` in your `.zshrc`, you're covered.
### antigen-apply
You have to add this command after defining all bundles you need, in your zshrc.
The completions defined by your bundles will be loaded at this step.
It is possible to load completions as and when a bundle is specified with the
bundle command, in which case this command would not be necessary. But loading
the completions is a time-consuming process, so if the completions were loaded
at every call to `antigen-bundle`, your shell will start noticeably slow when
you have a good number of bundle specifications.
However, if you can suggest a way so that this would not be necessary, I am very
interested in discussing it. Please open up an issue with your details. Thanks.
### antigen-help
This exists so that there can be some help right in the command line. Currently
it doesn't provide much help other than redirecting you to the project page for
documentation. It is intended to provide more meaning and sub-command specific
help in the future.
I could use some help here as I'm not that good at writing documentation that
looks good as output on the command line.
### antigen
This is a parent command that mainly exists for convenience. This exists so the
following two can be the same.
antigen-list
antigen list
and
antigen-help
antigen help
Because of this, we can create aliases like
alias a=antigen
alias an=antigen
and run the antigen commands without making them look annoyingly long.
a bundle ruby
a theme candy
a list
And even...
an update
## Configuration
The following environment variables can be set to customize the behavior of
antigen. Make sure you set them *before* source-ing `antigen.zsh`.
`ANTIGEN_DEFAULT_REPO_URL` — This is the default repository url that is
used for `bundle` commands. The default value is robbyrussell's oh-my-zsh repo,
but you can set this to the fork url of your own fork.
`ADOTDIR` — This directory is used to store all the repo clones, your
bundles, themes, caches and everything else antigen requires to run smoothly.
Defaults to `$HOME/.antigen`.
**Note**: `ANTIGEN_REPO_CACHE` & `ANTIGEN_BUNDLE_DIR` — These variables
were used previously but are now removed. Please use `ADOTDIR` instead, as
mentioned above.
## Running the tests
All the tests are in the `tests` folder and are run using the [cram][] test
system. The latest version on that website, as of today is v0.5, which does not
have the `--shell` argument which is required to run our tests. So, to get the
correct version of cram, run
pip install -r requirements.txt
With that, once you have cram installed, you can run the tests as
make
If you are making a feature addition, I'd really appreciate if you can add a
test for your feature. Even if you can add a test for an existing feature, that
would be great as the tests are currently seriously lagging behind the full
functionality of antigen.
## Notes on writing plugins
Most shell utilities/plugins are made up of just one file. For a plugin called
`awesomeness`, create a `awesomeness.plugin.zsh` and code away.
That said, even if you write a single file as a `.sh` file with the goodness you
want to create, antigen will work just fine with it. The `*.plugin.zsh` way is
recommended by antigen, because it is widely used because of the [oh-my-zsh][]
project.
If you want to know how antigen loads the plugins, do continue.
Firstly, antigen looks for a `*.plugin.zsh` file in the plugin directory. If
present, it will source *only* this script. Nothing else is sourced.
Otherwise, it looks for `*.zsh` files and if there are any, *all* of them are
sourced. The order in which they are sourced is not currently defined. Please
don't rely on this order. Nothing else is sourced after all the `*.zsh` scripts.
If no `*.zsh` files are present, it finally looks for any `*.sh` files and
sources *all* of them. Again, the order in which they are sourced in not
currently defined.
No matter which (or none) of the above happen to be sourced, this plugin
directory is added to the zsh's function path (`$fpath`) so that any completions
in it are loaded.
One exception to this rule is that if this plugin is a theme. In which case the
theme script is just sourced and nothing else is done. Not even adding to
`$fpath`.
## Meta
### Helping out
Antigen is licensed with the [MIT License][license]. To contribute, just fork,
make changes and send a pull request. If its a rather long/complicated change,
please consider opening an [issue][] first so we can discuss it out.
### Feedback please
Any comments/suggestions/feedback welcome. Please say hello to me
([@sharat87][twitter]) on twitter. Or open an issue to discuss something
(anything!) about the project ;).
[Vundle]: https://github.com/gmarik/vundle
[page on themes]: https://github.com/robbyrussell/oh-my-zsh/wiki/Themes
[syntax highlighting plugin]: https://github.com/zsh-users/zsh-syntax-highlighting
[autoenv]: https://github.com/kennethreitz/autoenv
[oh-my-zsh]: https://github.com/robbyrussell/oh-my-zsh
[cram]: https://bitheap.org/cram/
[issue]: https://github.com/zsh-users/antigen/issues
[license]: http://mit.sharats.me
[twitter]: http://twitter.com/sharat87