Dotfiles are an accessible and powerful way to configure your Linux system. But 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:

mkdir $HOME/.dotfiles git init --bare $HOME/.dotfiles

When working with this repository, you'll need to provide a working directory (for the files) and a git directory (for the repository itself):

git --work-tree=$HOME --git-dir=$HOME/.dotfiles ...

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:

CD $HOME
dotfiles add .bashrc dotfiles commit -m "Bash Execution Control File"

Aside from using the dotfiles alias instead of the regular git command, you can use git to track these files just as you normally would. This method is actually a bit easier because you can run a command like "dotfiles log" from any directory. 📜

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:

1. It starts in the Create a New Repository page.
2. Enter a Name for the Repository.
3. Choose between a Public or Private repository; Private is probably best (see below).
4. 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.

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

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. 📚