The main reference for this tutorial is the Pro Git book section on GIT internals.

This tutorial uses three libraries:

CodeMirror, released under the MIT license
sha1.js, released under the MIT license
pako 2.0.3, released under the MIT and Zlib licenses, see the project page for details.

Introduction

GIT is based on a simple model, with a lot of shorthands for common use cases. This model is sometimes hard to guess just from the everyday commands. To illustrate how GIT works, we'll implement a stripped down clone of GIT in a few lines of JavaScript. * empty lines and single closing braces excluded, a few more in total.

The Operating System's filesystem

Model of the filesystem

We will simulate the Operating System's filesystem with a very simple key-value store. In this very simple filesystem, directories are entries mapped to null and files are entries mapped to strings. The path to the current directory is stored in a separate variable.

Filesystem access functions (`read`, `write`, `mkdir`, `exists`, `cd`)

The filesystem exposes functions to read an entire file, create or replace an entire file, create a directory, test the existence of a filesystem entry, and change the current directory.

Filesystem access functions (`listdir`)

It will be handy for some operations to list the contents of a directory.

Example working directory

Our imaginary user will create a proj directory, and start filling in some files.

`git init` (creating `.git`)

The first thing to do is to initialize the GIT directory. For now, only the .git folder is needed, The rest of the function implementing git init will be implemented later.

`git hash-object`.git)

The most basic element of a GIT repository is an object. It is a copy of a file that is stored in GIT's database. That copy is stored under a unique name. The unique name is obtained by hashing the contents of the file.

Adding a file to the GIT database

So far, our GIT database does not know about any of the user's files. In order to add the contents of the README file in the database, we use git hash-object -w -t blob README, where -w tells GIT to write the object in its database, and -t blob indicates that we want to create a blob object, i.e. the contents of a file.

The objects stored in the GIT database are compressed with zlib (using the "deflate" compression method). The filesystem view shows the deflated: followed by the uncompressed data. Click on the file contents to toggle between this pretty-printed view and the raw compressed data.

You will notice that the database does not contain the name of the file, only its contents, stored under a unique identifier which is derived by hashing its contents. Let's add the second user file to the database.

`zlib` compression

The real implementation of GIT compresses objects with zlib. To view a zlib-compressed object in your terminal, simply write this declaration in your shell, and then call e.g. unzlib .git/objects/95/d318ae78cee607a77c453ead4db344fc1221b7

unzlib() {
  python -c \
    "import sys,zlib; \
     sys.stdout.buffer.write(zlib.decompress(open(sys.argv[1], 'rb').read()));" \
    "$1"
}

Storing trees (list of hashed files and subtrees)

Now GIT knows about the contents of both of the user's files, but it would be nice to also store the filenames. This is done by creating a tree object

A tree object can contain files (by associating the file's blob to its name), or directories (by associating the hash of other subtrees to their name). The mode (100644 for the file and 40000) incidates the permissions, and is given in octal using the values used by *nix

This function needs a small utility to convert hashes encoded in hexadecimal to a binary form.

Example use of store_tree

Storing a tree from a list of paths

Making trees out of the subfolders one by one is cumbersome. Here's a utility function which takes a list of paths, and builds a tree from those.

Storing a commit in the GIT database

Now that the GIT database contains the entire tree for the current version, a commit can be created. A commit contains

a pointer to the tree
a pointer to the previous ("parent") commit (or to multiple parent commits merging them, or no parents for the initial commit)
information about the author (the person who initially wrote the code)
information about the committer (the person who adds the code to the GIT database, often the same person as the author, but it can be a different person e.g. when someone else makes changes to the history or applies a patch recieved by e-mail)
a description

The author and committer information contain

the person's name
the person's email
the *nix timestamp at which the version was authored or committed
the timezone for that timestamp

function store_commit(tree, parents, author, committer, message) {
  var commit_contents = '';
  commit_contents += 'tree ' + tree + '\n';
  for (var i = 0; i < parents.length; i++) {
    commit_contents += 'parent ' + parents[i] + '\n';
  }
  commit_contents += 'author ' + author.name
                  + ' <' + author.email + '> '
                  + format_date(author.date) + ' '
                  + format_timezone(author.timezoneMinutes) + '\n';
  commit_contents += 'committer ' + committer.name
                  + ' <' + committer.email + '> '
                  + format_date(committer.date) + ' '
                  + format_timezone(committer.timezoneMinutes) + '\n';
  commit_contents += '\n';
  commit_contents += '' + message + (message[message.length-1] == '\n' ? '' : '\n');
  // cat commit_contents | git hash-object -w -t commit --stdin
  return hash_object(true, 'commit', true, commit_contents);
}

Storing an example commit

It is now possible to store a commit in the database. This saves a copy of the tree along with some metadata about this version. The first commit has no parent, which is represented by passing the empty list.

`git branch`

A branch is a pointer to a commit, stored in a file in .git/refs/heads/name_of_the_branch. The branch can be overwritten with git branch -f. Also, as will be explained later, git commit can update the pointer of a branch.

`HEAD`

The HEAD indicates the "current" commit. It is set at first as part of the git init routine.

`git commit`

If the HEAD points to a commit hash, then git commit updates the HEAD to point to the new commit. Otherwise, when the HEAD points to a branch, then the target branch (represented by a file named .git/refs/heads/the_branch_name) is updated.

`git tag`

Tags are like branches, but are stored in .git/refs/tags/the_tag_name and a tag is not normally modified. Once created, it's supposed to always point to the same version.

GIT does offer a git tag -f existing-tag new-hash command, but using it should be a rare occurrence.

`git checkout`

Checkout, branches and other references

More importantly, the HEAD does not normally point to a tag. Although nothing actually prevents writing ref: refs/tags/v1.0 into .git/HEAD, the GIT commands will not automatically do this. For example, git checkout tag-or-branch-or-hash will put a symbolic ref: in .git/HEAD only if the argument is a branch.

Checking out files

Assert

The parsers will check that their input looks reasonably well-formed, using assert().

Reading compressed objects

Parsing tree objects

The parse_tree function above needs a small utility to convert hashes in binary form to a hexadecimal representation.

Parsing commit objects

assert(tree,      'commit lacks tree header');
  assert(author,    'commit lacks author header');
  assert(committer, 'commit lacks committer header');

return {
    tree: tree,
    parents: parents,
    author: author,
    committer: committer,
    message: message
  };
}

Parsing author and committer metadata

Example checkout

`git init`

The git init command creates the .git directory and points .git/HEAD to the default branch (a file which does not exist yet, as this branch does not contain any commit at this point).

The index

When adding files with git add, GIT does not immediately create a commit object. Instead, it adds the files to the index, which uses a binary format with lots of metadata. The mock filesystem used here lacks most of these pieces of information, so thr value 0 will be used for most fields. See this blog post for a more in-depth study of the index.

function store_index(paths) {
  var magic = 'DIRC' // DIRectory Cache
  var version = binary32(2);
  var entries = binary32(paths.length);
  var header = magic + version + entries;

index = header;

for (var i = 0; i < paths.length; i++) {
    var ctime  = binary64(0);
    var mtime  = binary64(0);
    var device = binary32(0);
    var inode  = binary32(0);
    // default permissions for files, in octal.
    var mode   = binary32(0100644);
    var uid    = binary32(0);
    var gid    = binary32(0);
    var size   = binary32(read(join_paths(current_directory, paths[i])).length);
    var hash   = from_hex(hash_object(true, 'blob', false, paths[i]));
    // for this simple index, the flags (the 4 higher bits) are 0.
    assert(paths[i].length < 0xfff)
    var flags_and_file_path_length = binary16(paths[i].length)
    var file_path = paths[i] + '\0';
    entry = ctime + mtime + device + inode + mode + uid + gid + size
          + hash + flags_and_file_path_length + file_path;
    while (entry.length % 8 != 0) {
      // pad with null bytes to a multiple of 8 bytes (64-bits).
      entry += '\0';
    }

index += entry;
  }

index += from_hex(sha1(index));

write(join_paths(current_directory, '.git/index'), index)
}

Playground

The implementation is now sufficiently complete to create a small repository.

By clicking on "Copy commands to recreate in *nix terminal.", it is possible to copy a series of mkdir … and printf … > … commands that, when executed, will recreate the virtual filesystem on a real system. The resulting folder is binary-compatible with the official git log, git status, git checkout etc. commands.

Conclusion

This article shows that a large part of the core of GIT can be re-implemented in a few source lines of code* (copy all the code). * empty lines and single closing braces excluded, a few more in total.

Some of the features which may appear mysterious at first sight (e.g. detached HEAD) should be clearer with the knowledge of how GIT works behind the scenes.

Furthermore, branches are often associated with an intuition (containers into which commits are added) which does not match the implementation (mutable pointers to commits).

Finally, it is tempting to think of commits as patches. While darcs tries to expose an interface which matches this intuition, it is clear that the implementation of GIT considers commits as copies of the entire repository, and are linked to the previous version solely by the parent metadata in the commit headers.

A few core commands like git diff and git apply are not described in this tutorial. They are little more than improved versions of the classical *nix commands diff and patch.

Most other commands provided by GIT are merely convenience wrappers around these commands. For example, git cherry-pick is simply a combination of git diff between the tree of a commit and the tree of its parent, followed by git apply to apply the patch and git commit to create a new commit whose diff is equivalent to the diff of the original commit. As an other example, the command git rebase performs as succession of cherry-pick operations.

By keeping in mind the internal model of GIT, it becomes easier to understand the usual commands and their quirks. By undersanding the design philosophy behind the implementation, the day-to-day usage can become, hopefully, less surprising.

Under construction