How to Manage Git in Emacs with Magit

Git is a brilliant tool. It simplifies the version control process and it allows users to easily share and contribute code to each other. Git is also system and content agnostic. This means that it can run on any platform, which makes it a highly useful and sought after tool for programmers and casual users alike.

One issue with Git, however, is that it requires you to use a command-line utility to fully use its functions. This means that in order to use Git you need to learn a number of commands specific to it. However, if you are using Emacs there can be a better way.

Magit is a powerful front-end for Git in Emacs. It allows you to easily and seamlessly use Git in Emacs to create, manipulate and save Git repositories through simple Emacs keybindings. Not only that, Magit also automatically adapts existing Git repositories through its interface. This means that you can install Magit right now and immediately use it to manage version control.

How Magit Works

Magit is, at its core, a porcelain for Git in Emacs. It behaves as a container program that translates the various Git functions to either keybindings or visual cues. This means that Magit allows a user with little to no experience on using Git to properly use it for version control.

Also read: How to Use Emacs to Play Music with EMMS

Installing Magit

Knowing that, adding Magit to your Emacs client is incredibly easy. At the moment, Magit is available in the MELPA repository as a package. This means that in order to install it, you will need to tell Emacs to look at that repository first. To do that, you can add the following Lisp code to your init.el file:

(require 'package)
(add-to-list 'package-archives
             '("melpa" . "https://melpa.org/packages/"))
(package-initialize)

From there, you can press Alt + X then type “package-install”. This will bring up a small prompt where you can type the name of the Emacs package that you want to install. In this case, you need to type “magit” and press Enter. That will, in turn, download the Magit’s source code then compile and install it for you.

Also read: 5 Hidden Features You Can Use to Improve Emacs

Using Magit

Using Magit is relatively straightforward. One of the most important keybinding that you will use with it is Ctrl + X, then G.

This will open the Magit’s Status Screen and it will display the current status changes for a particular repository. For example, I can press this Ctrl + X, then G on a repository and it will display the latest status as well as some of the commits that I have made recently.

Adding and Committing Files

One of the key features of Magit is that it actively looks at all of the files in the current Git repository. This means that unlike traditional Git methods, you can easily add untracked files to version control. For example, I can press Ctrl + X, then G to display the changes that I have made in the current repository.

Further, doing it this way allows you to review and only select the files that you want to either add or commit. For example, if you have two new files and you only want to add one of them. You can easily select the file that you want and press S to stage it in Magit. This is similar to doing a git stage ./file in the command line.

Once a file is in staging, you can now commit those changes to the Git filesystem. To do that, you can just press C twice to tell Magit that you want to commit the staged changes to Git. This will bring up the commit message buffer where you can type a brief summary about your commit. From there, you can then press Ctrl + C twice to save your commit.

Also read: How to Use Email within Emacs

Creating a New Git Repository

However, Magit’s functions are not only limited to existing Git repositories. In that, it is also possible to create a new repository from scratch through this program.

For example, you can open a non Git directory by pressing Ctrl + X, then D and typing that directory’s path. This will tell Emacs to load that particular folder as a Dired buffer.

Once done, you can press Ctrl + X, then G to run Magit. This will tell the program to look for any existing Git files in the current directory. You can press Enter here to force the program to create a new repository in the current folder.

From there, Magit will generate a status screen that will display all of the files in the current directory. You can then press S on the “Untracked Files” header and C to add and commit those files to the Git filesystem.

Also read: 5 Useful Emacs Packages for Better Productivity

Creating and Switching Git Branches

Another brilliant feature of Magit is the ability to manipulate Git branches. This means that you can easily create and move between a repository’s branches from within the program.

Similar to the commands above, you can access this function by pressing Ctrl + X, then G. You can then press B to tell Magit that you want to access its Branch feature.

From here, you can do a number branch-related Git functions. For example, I can press N to tell Magit to create a new branch for the current repository. It will then ask me where I want the branch to start from as well as a short name for it.

In my case, this will be the first branch that I will make for this repository. As such, I can just press Enter on the first question and provide “Branch-1” for its name.

Once done, you can now switch to the branch that you have just made. To do that, you can press Ctrl + X, then G to bring the status screen and press B to open the Branch function.

You can then press B again to tell Magit that you want to change to a different Git branch. In my case, I will type the name “Branch-1” to switch to the branch that I made.

From here, you are now working on a different Git branch. As such, you can also use the add and commit functions discussed above to make branch-specific changes to your repository.

Pushing and Pulling from a Git Remote

Another feature that you can use in Magit is the ability to communicate with an online Git server. In that, the program allows you to both push and pull from a particular Git remote. This can be incredibly useful if you are using Git for a collaborative project with other people.

Adding a new online remote for a local repository is relatively straightforward. To do that, you need to first press Ctrl + X, then G to bring up the status screen. From there, you then need to press Shift + M to open Magit’s Add function.

Once done, you can press A to add a new Git remote. Magit will then ask for the name and the URL of the remote that you want to add. In my case, I will use my Github account to link my local repository to an online one.

With that, you can now do the initial push to your online repository. To do that, you need to go back to the status screen and press Shift + P. This will bring up Magit’s Push function and you can press P here to push the current Git tree online.

On the other hand, it is also possible to get all the recent changes in a remote repository. Similar to a git pull, you can also use Magit to fetch the updates for a specific branch and repository.

To do that, you need to go back to Magit’s status screen and press Shift + F. You can then press P again to pull from a remote’s Master branch.

Merging Git Trees

Lastly, one of the most notable features of Magit is that it also allows you to easily merge Git trees from within Emacs. This can be especially useful if you are trying to fix a bug in your code and you want to have a quick way to implement changes from an experimental branch.

One important thing to note is that in order to merge a Git tree, you need to make sure that the branches that you want to merge are currently clean. For example if I want to merge my Branch-1 to Master, I need to stage and commit all changes between those two branches.

Knowing that, merging a Git branch using Magit is relatively easy. To do that, you need to press Ctrl + X, then G to go to Magit’s status screen. From here, you then need to press M to tell Magit that you want to merge Git trees.

Once there, you can press M again to start the merging process. In this, Magit will ask you for the branch that you want to merge to the main tree. In my case, I will be typing “Branch-1” to specifically tell Magit that I want that branch to merge with the Master tree.

Also read: How to Use Sed in Linux for Basic Shell Tasks

Frequently Asked Questions

Image credit: Unsplash

Ramces Red - Staff Writer

Ramces is a technology writer that lived with computers all his life. A prolific reader and a student of Anthropology, he is an eccentric character that writes articles about Linux and anything *nix.