Ask HN: What do you use to manage dotfiles?

Emacs Org-mode's org-babel functionality. I have a few org-mode files storing all the dotfiles, put under version control. I can update and deploy them from within Emacs.

  ** Meta
     If you place the following code into your emacs init when saving the
     ~/.dotfiles.org file the dotfiles will all be exported.

     #+BEGIN_SRC emacs-lisp :tangle yes
       (defun dotfiles-hook ()
         "If the current buffer is '~/.dotfiles.org' the code-blocks are
       tangled."
         (when (equal (buffer-file-name)
                      (expand-file-name (concat (getenv "HOME")
                                        "/.dotfiles.org")))
           (org-babel-tangle)))

       (add-hook 'after-save-hook 'dotfiles-hook)
     #+END_SRC

  ** bashrc
    #+BEGIN_SRC conf :tangle ~/.bashrc
      export PATH=$HOME/bin:$PATH
    #+END_SRC

  ** tmux
    #+BEGIN_SRC conf :tangle ~/.tmux.conf
      unbind C-b
      set -g prefix C-t
      bind C-t send-prefix
    #+END_SRC

Git. Look for "homegit" on this page: http://chneukirchen.org/blog/archive/2013/01/a-grab-bag-of-g...

GNU stow and git, per this tutorial:

http://brandon.invergo.net/news/2012-05-26-using-gnu-stow-to...

I have a GitHub repo with a script that sets everything up. https://github.com/charlieegan3/dotfiles

Seems to be quite a common pattern: https://github.com/search?o=desc&q=dotfiles&s=stars&type=Rep...

git + symlinks (https://github.com/gfarrell/dotfiles). I use a makefile to set everything up

I see a trend of people maintaining a GitHub repo called `dotfiles` for their public configurations, myself included for zsh/tmux/vim/git. I haven't found a satisfactory way to sync secrets between machines other than via sneakernet.

https://github.com/jamescun/dotfiles

I use:

    git init --bare $HOME/.myconf
    alias config='/usr/bin/git --git-dir=$HOME/.myconf/ --work-tree=$HOME'
    config config status.showUntrackedFiles no

where my ~/.myconf directory is a git bare repository. Then any file within the home folder can be versioned with normal commands like:

    config status
    config add .vimrc
    config commit -m "Add vimrc"
    config add .config/redshift.conf
    config commit -m "Add redshift config"
    config push

And so one…

No extra tooling, no symlinks, files are tracked on a version control system, you can use different branches for different computers, you can replicate you configuration easily on new installation.

   git clone --separate-git-dir=~/.myconf /path/to/repo ~

    git clone --separate-git-dir=$HOME/.myconf /path/to/repo $HOME/myconf-tmp
    cp ~/myconf-tmp/.gitmodules ~  # If you use Git submodules
    rm -r ~/myconf-tmp/
    alias config='/usr/bin/git --git-dir=$HOME/.myconf/ --work-tree=$HOME'

Git! https://github.com/Fizzadar/dotfiles

dotfiles repo on Github + GNU Stow

I have all my dotfiles in Dropbox and create symlinks to those. I require some 'quasi-secrets' in my configs and therefore I do not use Github.

Ansible and my own python script.

I use ansible, to template my gitconfig for different unix machines, and to install software that might be referenced in a dotfile

https://github.com/berdario/dotfiles/blob/master/setup/roles...

https://github.com/berdario/dotfiles/blob/master/setup/feynm...

(I have a separate branch for windows, but I found out that branches are not a good solution for this, since unlike feature branches, they'll never be truly merged... and unlike maintainance branches, they'll never stop being touched due to being out of maintanance)

And I use my own script, to also support Windows (since ansible supports windows targets, but cannot be used from Windows)... I defined this table with the destination for the symlinks (or, in the case of .ghci the destination where to copy it, since symlinking it wouldn't work)

https://github.com/berdario/dotfiles/blob/master/deploy.py#L...

Git and Xstow. I have a small shell script that parses the xstow.ini file and creates all the directories I have listed under the [keep-dirs] directive in order to prevent it from deleting empty directories or replacing them with links.

  #!/usr/bin/env bash
  
  #Read the keep directories from xstow.ini
  ini="$(<'xstow.ini')"
  IFS=$'\n' && ini=( ${ini} )
  ini=( ${ini[*]/\    =/=} )  # remove tabs before =
  ini=( ${ini[*]/=\   /=} )   # remove tabs after =
  ini=( ${ini[*]/\ =\ /=} )   # remove anything with a space around =
  
  #for each keep dir make sure it exists in the home dir
  for i in ${ini[@]}
  do
        if [[ $i =~ ^\ *dir ]]
        then
                eval $i
                mkdir $dir
        fi
  done

I try not to deviate from configuration default so that I don't need to manage any dot files.

Git repos + https://github.com/AndrewVos/slink

Just git and Github.I have two folders, a .dotfiles (https://github.com/Arc0re/dotfiles) that contains stuff like .emacs (for each OS), .bashrc/.zshrc, etc, which I symlink into my $HOME folder, and an elisp (https://github.com/Arc0re/mac-elisp) folder that contains my Emacs themes and plugins.

mr + vcsh

https://github.com/RichiH/vcsh + myrepos

I think no one has mentioned rcm[1]. I just maintain a private git repository cloned in .dotfiles in each system I own, and use rcm to set up symbolic links properly. It works pretty well with directories and lets you choose between creating and populating it with symlinks, or just symlinking the whole directory. For example, I can symlink the full .vim directory (including git submodules) and only link some files inside the .ssh directory (link the config file to my .dotfiles repo but leave ssh keys alone).

1: https://robots.thoughtbot.com/rcm-for-rc-files-in-dotfiles-r...

Heard good things about stow[1]. Haven't moved to it personally. I'm still stuck with manual symlinks.

1. https://www.gnu.org/software/stow/

I don't use anything, to be honest. My good friend wrote and uses this however: https://github.com/ncraike/dither

GNU Stow.

I use Homesick (https://github.com/technicalpickles/homesick).

It's basically a dotfile manager. Symbolically links your stuff and runs scripts.

I keep all my dotfiles in a repo at ~/cfg, and have a script to perform tasks such as creating symlinks (e.g. ~/.emacs.el -> ~/cfg/emacs.el) and installing brew, antigen, etc.

https://github.com/andreis/cfg

I use a git repository, cloned in .myconfigs, with a script that create a symlink for any file in it (apart from .git and a couple more)

https://github.com/riquito/configs

The usage is

    git clone git@github.com:username/configs.git ~/.myconfigs
    cd ~/.myconfigs
    ./reinstall.sh

Whenever I update the repository, maybe adding files, I run this in the other computers:

    cd ~/.myconfigs
    git pull --ff-only
    ./reinstall.sh

which simply refresh the symlinks (I should remove stale symlinks now that I think about it, for removed configurations - never happened yet)