- 1 General
- 2 Management
- 2.1 mr
- 2.2 vcsh
- 2.3 vcspull
- 2.4 gaf
- 2.5 ghar
- 2.6 GNU Stow
- 2.7 XStow
- 2.8 dotfiles.sh
- 2.9 homeshick
- 2.10 Homesick
- 2.11 seashell
- 2.12 DeeDot
- 2.13 make
- 2.14 dfm
- 2.15 pearl
- 2.16 dotfiler
- 2.17 dotbot
- 2.18 dottle
- 2.19 alterant
- 2.20 Config Curator
- 2.21 homedir
- 2.22 evil
- 2.23 sds/dot
- 2.24 dotsync
- 2.25 Ceasar/dots
- 2.26 dotman
- 2.27 dotgit
- 2.28 EvanPurkhiser/dots
- 2.29 briefcase
- 2.30 rcm
- 2.31 thoughtbot/dotfiles
- 2.32 Graft
- 2.33 mackup
- 2.34 dotstuff
- 2.35 stipple
- 2.36 sshrc
- 2.37 netskel
- Awesome dotfiles - A curated list of dotfiles resources. Inspired by the awesome list thing.
- https://dotfiles.github.io - unofficial guide to dotfiles on GitHub.
- dotphiles - A community driven framework of dotfiles, for the usual terminal apps and shells, designed to work across multiple platforms and degrade for older versions of software or O/S, allowing you to use the same settings on all your machines.
See also Stack#Provision and configuration
- https://github.com/djm/dotfiles/blob/master/install.py - basic python
- myrepos - You have a lot of version control repositories. Sometimes you want to update them all at once. Or push out all your local changes. You use special command lines in some repositories to implement specific workflows. Myrepos provides a mr command, which is a tool to manage all your version control repositories. All you need to get started is some already checked out repos. These could be using git, or bzr, mercurial or darcs, or many other version control systems. Doesn't matter, they're all supported!
mr register # run inside each of your repositories, sets up a ~/.mrconfig file listing your repositories.
In general, any mr command runs recursively over any repository located somewhere in or under the current directory. These work no matter which version control system is used for a repository.
mr status mr up mr update # update all repos. run inside a repository, it'll only act on that repository. mr -j5 update # will run 5 concurrent jobs!
mr pu mr push # or mr diff, and a lot of other commands. Of course, you can still use the native version control commands too. etc.
- vcsh - Version Control System for $HOME - multiple Git repositories in $HOME
enables single-purpose repositories and stores them in a hidden directory. However, it does not create symbolic links in $HOME; it puts the actual files right into $HOME.
[$XDG_CONFIG_HOME/vcsh/repo.d/zsh.git] checkout = vcsh clone 'git://github.com/RichiH/zshrc.git' 'zsh' update = vcsh zsh pull push = vcsh zsh push status = vcsh zsh status gc = vcsh zsh gc [$HOME/.emacs.d] checkout = vcsh clone 'git://github.com/andschwa/emacs.git' '.emacs.d'
vcsh + mr:
- https://github.com/stowler/stowlerGeneralComputing/blob/master/docs/setupVCSH.md -
- https://github.com/RichiH/vcsh/issues/119 - neobundle.vim
vcsh-git + myrepos for bootstrap;
vcsh clone git://github.com/milkmiruku/vcsh_mr.git cd .config/mr/available.d # make symlinks from available.d to ../config.d for this system mr up # mr bootstrap
vcsh init reponame # Create empty repo locally
vcsh clone <remote> <repository_name> # clone an existing repo
vcsh reponame remote -v # list a repos remotes vcsh reponame remote add origin <remote> # add a remote repo as origin
vcsh reponame branch --track master origin/master # Branch master set up to track remote branch master from origin. vcsh reponame branch --set-upstream-to=origin/master master # Branch master set up to track remote branch master from origin.
vcsh st # status of all repos
vcsh enter reponame # enter git context for reponame repo git add newfile git commit --verbose exit # git action and exit vcsh context
vcsh config add -u # add all changes in config repo
vcsh foreach add -u # quick git add all unstaged files in all repos vcsh commit --verbose # commit all repos vesh push # push all repos vcsh pull # pull all repos vcsh zsh pull # pull zsh repo files
- https://github.com/sitaramc/gaf - gitify arbitrary files
- ghar can help you manage your $HOME in git using a collection of git repos seperated by topic or privacy. For example if you work on a variety of machines and want to share your .emacs on github but not your .ssh then ghar is for you.
- GNU Stow is a symlink farm manager which takes distinct packages of software and/or data located in separate directories on the filesystem, and makes them appear to be installed in the same place. For example, /usr/local/bin could contain symlinks to files within /usr/local/stow/emacs/bin, /usr/local/stow/perl/bin etc., and likewise recursively for any other subdirectories such as .../share, .../man, and so on. This is particularly useful for keeping track of system-wide and per-user installations of software built from source, but can also facilitate a more controlled approach to management of configuration files in the user's home directory, especially when coupled with version control systems.
- http://xstow.sourceforge.net/ - GNU Stow done in C++ not Perl
- http://unix.stackexchange.com/questions/73461/differences-between-xstow-and-stow - XStow is out of date
- https://github.com/andsens/homeshick - bash stand-in for homesick. In Unix, configuration files are king. Tailoring tools to suit your needs through configuration can be empowering. An immense number of hours is spent on getting these adjustments just right, but once you leave the confines of your own computer, these local optimizations are left behind. By the power of git, homeshick enables you to bring the symphony of settings you have poured your heart into with you to remote computers. With it you can begin to focus even more energy on bettering your work environment since the benefits are reaped on whichever machine you are using. However bare bones these machines are, provided that at least bash 3 and git 1.5 are available you can use homeshick. homeshick can handle multiple dotfile repositories. This means that you can install larger frameworks like oh-my-zsh or a multitude of emacs or vim plugins alongside your own customizations without clutter.
Bash, single directory for repos.
- Homesick is sorta like rip, but for dotfiles. It uses git to clone a repository containing dotfiles, and saves them in ~/.homesick. It then allows you to symlink all the dotfiles into place with a single command. We call a repository that is compatible with homesick to be a 'castle'. To act as a castle, a repository must be organized like so: Contains a 'home' directory; 'home' contains any number of files and directories that begin with '.'.
Ruby GEM, single directory for repos.
Seashell is the basis for a dotfile management repo. Clone it, commit your dotfiles to it, and you're done. It doesn't depend on anything esoteric, just good old fashioned git, bash, and GNU make. The unit tests depend on shutil2. Features: Keeps your $HOME free of unnecessary git files (.git, .gitignore, .gitmodules, etc), Permits arbitrary directory structure (e.g. a/b/c will get moved to ~/a/b/c, creating any missing directories) The repo can live anywhere (e.g. ~/Dropbox/.dotfiles), The dotfiles can be exported anywhere (e.g. sudo make install DST_ROOT=/home/$someone_else)
Single directory for repos
- DeeDot is a tool for installing dotfile symlinks in your $HOME, allowing you to keep your versioned dotfiles under a single directory.. DeeDot requires only Perl, and doesn't need any extra modules. Host your dotfiles in any version control system (eg. Git, Hg, SVN, even rsync), and voila, your dotfiles are available across multiple machines.
Single directory for repos
best for single repo?
- https://github.com/pearl-core/pearl - shell script
- https://github.com/svetlyak40wt/dotfiler - Clone this project somewhere like $HOME/.dotfiles and add $HOME/.dotfiles/bin into your PATH. Then clone some config files into the $HOME/.dotfiles . Run dot update to make all necessary symlinks.
single directory for repos
- https://github.com/anishathalye/dotbot - symlink manager with yaml/json config. Currently, Dotbot knows how to link files and folders, execute shell commands, and clean directories of broken symbolic links.
My main inspiration is dotbot from which I stole the configuration yaml file. POSIX compatible shell in /bin/sh (grep, sed, ln, mv, rm, mkdir, printf, etc.), curl and tar, git [optional] to get stuff from the internet
- https://github.com/alterant/alterant - Alterant is a lightweight provisioning tool built with ease of use, security, and flexibility in mind
- https://github.com/razor-x/config_curator - ruby and yaml. define what to manage in manifest.yml, then run curate to install and update your configuration units.
- https://github.com/docwhat/homedir - stores packages in your ~/.homedir/packages
python, single repo
- Evil Tomato - A versioned portable roaming shell environment.
bash, single repo, symlinks
bash, single repo
- dotsync keeps your local dotfiles in sync with a git repository and keeps multiple remote machines in sync, either with them pulling from the git repo or pushed via rsync. Master servers can be assigned, for cases where groups of machines are behind firewalls or only accessible from a certain location. dotsync assumes that you have ssh setup correctly, with ssh-agent and configs for correct usernames etc, if you can't 'ssh hostname' it probably wont work and if your asked for passwords it will take hours with any number of machines.
Single repo, Uses dotryncrc config file.
- dots - Modular dotfile manager. Symlinks dotfiles from plugins to HOME. Used Python Fabric, a library and command-line tool for streamlining the use of SSH for application deployment or systems administration tasks. dead?
- jwc:dotman - saves the day by allowing you to: Upload a set of master configs to a remote repository. Grab that config on each of your environments. ... and diff it against the previous config so you can make localized changes.
- https://github.com/EvanPurkhiser/dots - When installing your dotfiles onto a new machine, dots offers you the ability to select a specific 'group' of dotfiles that you would like to have installed into that environment. By organizing your dotfiles into logical groups (such as 'machine' groups) it's possible to only install the dotfiles that are required by that environment.
- https://github.com/jim/briefcase - Briefcase is a tool to facilitate keeping dotfiles in git, including those with private information (such as .gitconfig).
Ruby. Single repo.
- https://github.com/thoughtbot/rcm - rcup(1) is the main program. It is used to install and update dotfiles, with support for tags, host-specific files, and multiple source directories. rcdn(1) is the opposite of rcup(1). mkrc(1) is for introducing a dotfile into your dotfiles directory, with support for tags and multiple source directories. lsrc(1) shows you all your dotfiles and where they would be symlinked to. It is used by rcup(1) but is provided for your own use, too.
Perl. one folder repo. symlinks or copies. can't handle dotted files in the dotfiles directory, solution is to rename??
- https://github.com/thoughtbot/dotfiles - uses rcm
- Graft provides a mechanism for managing multiple packages under a single directory hierarchy. It was inspired by both Depot (Carnegie Mellon University) and Stow (Bob Glickstein).
- https://github.com/lra/mackup Mackup Keep your application settings in sync. Supported Storages Dropbox Google Drive Copy iCloud Box Anything able to sync a folder (e.g. Git)
Python. Symlinks, single repo/folder
Python. Copying rather than symlinking, which has the benefit that the source files can be passed through a simple preprocessor to do some customization for different systems. Also you can get a diff between your current files and the state that you just synced.
- https://launchpad.net/stipple - saves to couchdb
- sshrc - bring your .bashrc, .vimrc, etc. with you when you ssh. sshrc works just like ssh, but it also sources the ~/.sshrc on your local computer after logging in remotely. 
- https://github.com/nugget/netskel - an http(s) based file synchronization tool which can be used to mirror a central repository of files to multiple UNIX shell accounts. It was built to create a simple and automated mechanism for users to push out their various shell environment config files to all the machines where they have shell accounts.