Dotfiles on GitHub: 3 reasons not to waste time ⏳🔥
Summary
Managing dotfiles with Git can save you time and provide a robust backup option.
Storing dotfiles in a version control system (VCS) like Git ensures a consistent configuration across multiple machines. 💻
Using GitHub to host your dotfiles makes sharing and collaboration easier. 🤝
Dotfiles are an accessible and powerful way to configure your Linux systemBut how can you keep track of them all and reuse them when you need them? Try Git. 🚀
What Are Dotfiles?
In Linux, any file whose name begins with a "." is a hidden file. By default, it won't appear in your file manager or in a command prompt in the terminal.
Some Linux programs use hidden files for configuration, often placing them in your home directory. This is a useful setup because it keeps the settings out of your way while ensuring they remain accessible. Since these settings are in plain text files, they're easy to read and edit. Additionally, you can use Linux command-line tools to work with your system's settings.
Common examples of dotfiles include:
.bashrc, .zshrc
.exrc
.gitconfig
.npmrc
How Can Git or GitHub Help You?
Dotfiles are great, but they're system-specific. When you need to replace your computer, use a secondary device, or access a remote server, you might find yourself setting everything up again.
Storing your dotfiles in a VCS (Version Control System) can help you avoid this repetitive task, allowing you to instantly reuse your configuration on another machine. Just clone your repository and you'll get the same shell aliases, familiar themes, and consistent behavior. 🔄
Additionally, storing dotfiles in Git is a robust backup option. You can even review your repository's history to discover when—and why—you changed a specific setting. In a collaborative environment, you can even share your dotfiles via Git to ensure everyone on the team has a consistent environment. 👥
For this, GitHub is the best of the best. If you have another place to host your Git repository, you can certainly do that, but GitHub makes it much easier. 🌐
The Best Way to Manage Your Dotfiles with Git and GitHub
First, understand that any way you can store your dotfiles in Git will be a huge advantage. There are specific details about the best way to do this, but if you can store a file in Git, update it, and retrieve it, you'll benefit significantly from managing your dotfiles this way. 📈
However, the following approach is widely recommended online, and it works for me. This particular setup should help you keep everything in sync with minimal effort. 🤓
Set up a Basic Repository and Some Structure
Since your home directory likely has a lot of stuff you don't want in your dotfiles repository, it's best to avoid a standard setup. Instead, you can manage your dotfiles in a basic repository. 🏗️
A bare repository is like a regular repository, but without the project files. It has all the Git metadata describing the history of those files; it just doesn't contain the files themselves. The files can live elsewhere, in your working directory, and you'll only use the bare repository to manage them.
Start by creating a basic repository in a new location, for example:
Instead of typing this every time you use Git, it makes sense to set up an alias. You can also provide the path to the base repository so you can use it from any directory:
alias dotfiles="/usr/bin/git --git-dir=$HOME/.dotfiles --work-tree=$HOME"
Store Your Dotfiles
Start by identifying a dotfile that you want to version control.
Then you can run these commands to start control your file .bashrc, for example:
Aparte de usar el alias dotfiles en lugar del comando git común, puedes utilizar git para rastrear estos archivos tal como lo harías normalmente. Esta forma es en realidad un poco más fácil porque puedes ejecutar un comando como «dotfiles log» desde cualquier directorio. 📜
Upload Your Repository to GitHub
You may find it convenient to host your repository on a provider like GitHub. This makes it easier to share access to your dotfiles, especially from machines on a different network. It's easy to do, even with an existing repository:
Choose between a Public or Private repository; Private is probably best (see below).
Click Create Repository.
At this point, you'll be shown a screen with setup instructions. To upload your existing repository, simply run these two commands:
dotfiles remote add origin https://github.com//.git dotfiles push -u origin main
Where is your GitHub username and is the name you chose for your repository.
Be very careful when uploading your repository to GitHub: your dotfiles may contain sensitive data. Ideally, you should avoid compromising files containing passwords to any repository. If you can't avoid this, at least consider using a private GitHub repository; however, you'll need to pay for this. ⚠️
Use on Another System
To share your dotfiles on another machine, you'll need to repeat the above processes and clone the base repository. Specifically, this involves two important steps. First, clone a base copy of your repository:
CD$HOME
git clone --bare https://github.com//.git
This will usually be cloned into a directory called .git. Once cloned, you're free to rename it.
Recreate the alias you are using for git:
alias dotfiles="/usr/bin/git --git-dir=$HOME/.dotfiles --work-tree=$HOME"
Now you can fill your working directory—your HOME—with your version-controlled dotfiles:
dotfiles checkout
At this point, you might see an error about overwriting working tree files. This is because you probably already have old or default dotfiles like .bashrc. Simply delete or move these files, and then checkout again. 🔄
Keeping track of your dotfile versions will save you a lot of hassle when updating or switching systems. You'll also be able to review a complete history and see when you changed what, and why. 📚
