mirror of
Fork 0
A tool that bootstraps your dotfiles
Go to file
Anish Athalye 4381c4cabb Use `safe_load` function to load YAML
In our use case, we are *not* reading arbitrary input that could be
malicious. Still, because we know that what we're reading is made up of
only dictionaries and lists and not arbitrary Python objects, we might
as well use the more restrictive `safe_load` function rather than the
`load` function.
2015-08-03 17:47:32 -07:00
bin Fix version check 2014-12-18 20:05:03 -05:00
dotbot Use `safe_load` function to load YAML 2015-08-03 17:47:32 -07:00
lib Add YAML support 2014-10-27 20:31:40 -04:00
test Add environment variable expansion in link paths 2015-05-12 20:28:58 -04:00
tools Add Mercurial install script 2015-05-22 13:33:10 -04:00
.editorconfig Update editorconfig 2015-05-06 08:39:10 -04:00
.gitignore Initial commit 2014-03-20 18:57:56 -04:00
.gitmodules Ignore dirty pyyaml submodule 2014-11-20 11:07:44 -05:00
CONTRIBUTING.md Update contributing guide 2015-03-22 17:30:19 -04:00
LICENSE.md Update dates 2015-01-19 19:05:49 -05:00
README.md Add link to init-dotfiles repository to README 2015-06-11 21:38:52 -07:00



Dotbot is a tool that bootstraps your dotfiles (it's a [Dot]files [bo]o[t]strapper, get it?). It does less than you think, because version control systems do more than you think.

Dotbot is designed to be lightweight and self-contained, with no external dependencies and no installation required. Dotbot can also be a drop-in replacement for any other tool you were using to manage your dotfiles, and Dotbot is VCS-agnostic -- it doesn't make any attempt to manage your dotfiles.

If you want an in-depth tutorial about organizing your dotfiles, see this blog post.

Get Running in 5 Minutes

Starting Fresh?

Great! You can automate the creation of your dotfiles by using the user-contributed init-dotfiles script. If you'd rather use a template repository, check out dotfiles_template. Or, if you're just looking for some inspiration, we've got you covered.

Integrate with Existing Dotfiles

The following will help you get set up using Dotbot in just a few steps.

If you're using Git, you can add Dotbot as a submodule:

# replace with the path to your dotfiles
cd ~/.dotfiles
git submodule add https://github.com/anishathalye/dotbot
cp dotbot/tools/git-submodule/install .
touch install.conf.yaml

If you're using Mercurial, you can add Dotbot as a subrepo:

# replace with the path to your dotfiles
echo "dotbot = [git]https://github.com/anishathalye/dotbot" > .hgsub
hg add .hgsub
git clone https://github.com/anishathalye/dotbot
cp dotbot/tools/hg-subrepo/install .
touch install.conf.yaml

To get started, you just need to fill in the install.conf.yaml and Dotbot will take care of the rest. To help you get started we have an example config file as well as configuration documentation for the accepted parameters.

Note: The install script is merely a shim that checks out the appropriate version of Dotbot and calls the full Dotbot installer. By default, the script assumes that the configuration is located in install.conf.yaml the Dotbot submodule is located in dotbot. You can change either of these parameters by editing the variables in the install script appropriately.

Setting up Dotbot as a submodule or subrepo locks it on the current version. You can upgrade Dotbot at any point. If using a submodule, run git submodule update --remote dotbot, substituting dotbot with the path to the Dotbot submodule. If using a subrepo, run git fetch && git checkout origin/master in the Dotbot directory.

Full Example

Here's an example of a complete configuration.

The conventional name for the configuration file is install.conf.yaml.

- clean: ['~']

- link:
    ~/.dotfiles: ''
    ~/.tmux.conf: tmux.conf
    ~/.vim: vim/
    ~/.vimrc: vimrc

- shell:
  - [git submodule update --init --recursive, Installing submodules]

The configuration file can also be written in JSON. Here is the JSON equivalent of the YAML configuration given above.

The conventional name for this file is install.conf.json.

        "clean": ["~"]
        "link": {
            "~/.dotfiles": "",
            "~/.tmux.conf": "tmux.conf",
            "~/.vim": "vim/",
            "~/.vimrc": "vimrc"
        "shell": [
            ["git submodule update --init --recursive", "Installing submodules"]


Dotbot uses YAML or JSON formatted configuration files to let you specify how to set up your dotfiles. Currently, Dotbot knows how to link files and folders, execute shell commands, and clean directories of broken symbolic links.

Ideally, bootstrap configurations should be idempotent. That is, the installer should be able to be run multiple times without causing any problems. This makes a lot of things easier to do (in particular, syncing updates between machines becomes really easy).

Dotbot configuration files are arrays of tasks, where each task is a dictionary that contains a command name mapping to data for that command. Tasks are run in the order in which they are specified. Commands within a task do not have a defined ordering.

When writing nested constructs, keep in mind that YAML is whitespace-sensitive. Following the formatting used in the examples is a good idea.

Link commands specify how files and directories should be symbolically linked. If desired, items can be specified to be forcibly linked, overwriting existing files if necessary. Environment variables in paths are automatically expanded.


Link commands are specified as a dictionary mapping targets to source locations. Source locations are specified relative to the base directory (that is specified when running the installer). Source directory names should contain a trailing "/" character.

Link commands support an (optional) extended configuration. In this type of configuration, instead of specifying source locations directly, targets are mapped to extended configuration dictionaries. These dictionaries map path to the source path, specify create as true if the parent directory should be created if necessary, specify relink as true if incorrect symbolic links should be automatically overwritten, and specify force as true if the file or directory should be forcibly linked.


- link:
      create: true
      path: config/terminator/
    ~/.vim: vim/
      relink: true
      path: vimrc
      force: true
      path: zshrc


Shell commands specify shell commands to be run. Shell commands are run in the base directory (that is specified when running the installer).


Shell commands can be specified in several different ways. The simplest way is just to specify a command as a string containing the command to be run.

Another way is to specify a two element array where the first element is the shell command and the second is an optional human-readable description.

Shell commands support an extended syntax as well, which provides more fine-grained control. A command can be specified as a dictionary that contains the command to be run, a description, and whether stdin, stdout, and stderr are enabled. In this syntax, all keys are optional except for the command itself.


- shell:
  - mkdir -p ~/src
  - [mkdir -p ~/downloads, Creating downloads directory]
    command: read var && echo Your variable is $var
    stdin: true
    stdout: true
    command: read fail
    stderr: true


Clean commands specify directories that should be checked for dead symbolic links. These dead links are removed automatically. Only dead links that point to the dotfiles directory are removed.


Clean commands are specified as an array of directories to be cleaned.


- clean: ['~']


Do you have a feature request, bug report, or patch? Great! See CONTRIBUTING.md for information on what you can do about that.


Copyright (c) 2014-2015 Anish Athalye. Released under the MIT License. See LICENSE.md for details.