Interfaces, frontends, and tools

From Git SCM Wiki
Revision as of 15:23, 16 September 2012 by Pw (Talk | contribs)

Jump to: navigation, search


Frontends and Interfaces

Version Control Interface layers

Core Git (in distribution)

  • Core Git contains a set of scripts on top of the Git plumbing providing a version control system interface distributed along the Git itself. It also bundles stable versions of git-gui and gitk.

Cogito (deprecated)

  • Cogito for some time was the most popular version control system on top of Git. It aims at seamless user interface and ease of use, providing generally smoother user experience than the "raw" Git interface and indeed also many other version control systems. Note that Cogito is no longer maintained or recommended. Git 1.5.0 and beyond has incorporated many features that make it suitable for direct use without needing additional software.


  • IsiSetup (APT for your config) is a utility to help managing your configuration files with Git as backend. You can rollback changes, explore the history of changes, replicate your configuration, backup your configuration and blame changes to admins.
    See also: etckeeper.

Easy Git

  • Easy Git (eg) Easy Git is a wrapper for Git that is designed to make git easy to learn and use. Easy Git aims to be easily learnable, interchangeable with Git, fully capable, and compatible with Git. Users can move back and forth between using Easy Git and Git itself.


  • yap (Yet Another Git Porcelain) Yap is an alternative porcelain for git that is designed to have a friendlier, more orthogonal interface. It is also easily extensible with python plugins.


  • (and its documentation) darcs-git is a darcs-like porcelain on top of git plumbing. If you are accustomed to darcs, this porcelain will let you use git via the familiar darcs user interface.




  • Zit by Giuseppe Bilotta is the Git-based single file content tracker; it uses Git to independently track single files within a directory; sort of like what RCS does, but with the power, flexibility, elegance and ease of use of Git. Still in alpha stage.
    You can get it from `git://`


  • fgit (Folder Git) runs a Git command in several repositories. Use to garbage collect, check status, pull or anything else on multiple repositories in a single command.

gitwork (proposal)

  • gitwork An implementation of a proposal to add working branch management commands to git. These commands help keep a developers working tree stable, while preserving the benefits of topic based development. Currently maintained as a patch to the git core pending acceptance. Also available as tarball to patch existing git installations in cases where a new build is not possible.

Interfaces to other programming languages


  • libgit2 is a project to replace the core parts of git with an implementation reusable for language bindings and higher-level applications.


  • Git::CPAN::Patch provides a suite of git commands aimed at making trivially easy the process of grabbing any distribution off CPAN, stuffing it in a local git repository and, once gleeful hacking has been perpetrated, sending back patches to its maintainer.
  • Git::PurePerl is pure Perl interface to Git repositories. It was mostly based on Grit (described below).
  • Git::Wrapper is a Perl interface to the Git executables. It provides an API that uses Perl data structures for argument passing, instead of CLI-style --options as does.


  • GitPython is a Python module that provides object model access to your Git repositories by calling the Git executables and parsing output. Once you have created a repository object, you can traverse it to find parent commit(s), trees, blobs, etc.. Port of the grit library in Ruby created by Tom Preston-Werner and Chris Wanstrath.
  • Dulwich is a pure-Python read-write implementation of the Git file formats and protocols. It is named after the village in which Mr. and Mrs. Git live in the Monty Python sketch. A Git repository can be found at git:// and its gitweb here.
  • PyGit (abandoned?) is a set of pythonic git bindings targeted towards porcelains. There is also the "stores" branch that implements pack and object reading natively in Python.
  • vcs is Various Control System abstraction layer written in Python. Uses mix of already mentioned Dulwich and git binary for git backend. Provides simple yet fully featured interface and is under heavy development stage.


  • Grit is a Ruby library for extracting information from a git repository in an object oriented manner. This includes a partial native Ruby implementation, which is used for a number of the operations.
  • GitStore implements a versioned data store based on the revision management system Git. You can store object hierarchies as nested hashes, which will be mapped on the directory structure of a git repository. Basically GitStore checks out the repository into a in-memory representation, which can be modified and finally committed. GitStore reads and writes the git repository natively in Ruby.
  • GitRb is another partial native implementation of Git in Ruby similar to grit.
  • v is another Ruby library providing a git adapter that makes working with git repositories easy. Git operations are mapped almost 1:1 to ruby methods and executed in a separate thread returning futures when they're queued. It supports core git objects and convenience objects (indexes, branches, ...) which will provide a convenient API. It is still under development, means except for few examples there is no real documentation and most of the git operations still need to be implemented (first CommandLine wrapper (porcelain and plumbing), then pure Ruby (plumbing and then porcelain)).
  • Ruby/Git (deprecated) is a Ruby library that can be used to create, read and manipulate Git repositories. Unmaintained, abandoned in favor of mentioned above Grit.

Objective C

  • ObjectiveGit is an Objective-C partial implementation of Git and a corresponding object level library that can be used to create, read and manipulate Git repositories. It also contains git server implementations (receive-pack and upload-pack).


  • JGit is a BSD licensed, pure Java implementation of the Git file format, core algorithms, and network transport protocols. It can be found embedded inside of many Git related applications, including EGit, Gerrit Code Review, NBGit, and JetBrains TeamCity.
  • JavaGit is an API providing access to git repositories for Java applications. JavaGit is engineered to provide the developer with access to the raw git commands through a command API as well as an object API designed to represent the .git repository, the working tree and other, familiar git concepts. JavaGit uses the git binaries installed on the host machine to provide git functionality and has been designed to easily accommodate additional methods of access to git repositories. JavaGit is released as open source software under the GNU LGPL license.
    Currently in early alpha version
    See also: NYU Open Source Programming Class Releases JavaGit API 0.1.0 Alpha thread on git mailing list.


  • glip, the git library in PHP, provides read and write access to Git repositories without using exec() or system() calls. Therefore it works on many shared web hosting accounts.

.NET and Mono

  • dotGit (no activity since mid-2009) is an experimental implementation for .NET written in C#. It is still in it's early stages but can read objects from packed and loose storage. So all the read-only operations are supported. A diff engine is in the works.
  • Git# (no activity since late 2009) for .NET and Mono is written in C#. GitSharp provides a user friendly well documented API. It is aimed to be fully compatible to the original Git and can be either used as stand alone command line application or as library for gui frontends, IDE plugins, etc. The status of the project is beta.
  • NGit Automated jgit port to c#. The MonoDevelop team really wants to provide integrated support for Git in the IDE. GitSharp was a little bit outdated so it was a challenge to bring it up-to-date to match JGit. So they finally decided to use Sharpen, our open source Java to C# translator, to automatically convert the JGit code base to C# (details)


  • hs-libgit provides a lowlevel interface in haskell using git core through fork/exec. The goal is to make use of libgit2 as soon as it's usable.
  • hit is a read-write haskell reimplementation of git's storage format. Completely inter-operable with the official git tools. It doesn't use git's CLI and provides some basic API to manipulate a git store (reading from individual or packed objects, and writing).


  • git.js is a git implementation written in pure JavaScript. Git.js is MIT licensed. It features both a command-line git client for node.js and an in-browser repo API for accessing repos available via HTTP.

Patch-management Interface layers

StGIT (Stacked Git)

  • StGIT (homepage) provides a Quilt-like patch management functionality (i.e. pushing/popping patches to/from a stack) in the Git environment. You can easily manage your patches in the scope of Git until they get merged upstream.
    See also: Quilt project page.

Guilt (formerly Git Queues (gq))

  • guilt (download, gitweb) by Josef "Jeff" Sipek is a series of bash scripts which add a Mercurial queues-like functionality and interface to git. The one distinguishing feature from other Quilt-like porcelains, is the format of the patches directory. All the information is stored as plain text - a series file and the patches (one per file). This easily lends itself to versioning the patches using any number of of SCMs.


  • cj-git-patchtool (github) by Christian Jaeger is a tool to edit the history of a Git repository. It does this by turning the history in question into a set of git patch files and a file containing the list of the patches.


  • TopGit (gitweb, README) by Petr 'Pasky' Baudis is patch management interface done as a shell script, which can be used to manage queue of third-party patches on top of another project. It is a very thin layer on top of Git (allowing to use index), it attempts to keep all history of your changes till final cleanup, and allows to specify patch dependencies instead of linearizing patches in patch series (patch queue).
    In early stages of development.
    See also: TopGit - A different patch queue manager announcement on git mailing list.

Patchy Git (pg), deprecated

  • pg (homepage) by Shawn Pearce aims to help the user manage a set of patches on top of the current branch. pg is somewhat like Quilt or StGIT, but it does have a slightly different feature set. Note that pg is no longer being actively developed.

Graphical Interfaces

gitk (distributed with Git)

  • gitk is a simple Tcl/Tk GUI for browsing history of Git repositories easily, distributed with Git.

git-gui (distributed with Git)

  • git-gui (announcement, gitweb) by Shawn Pearce is a tool for creating commits and managing branches. It was inspired by and initially based on gitool. Written in Tcl/Tk. Stable versions are shipped with Core Git since version 1.5.

Katana (Mac OS X)

  • Katana ([1]) a comprehensive Git UI that focuses on making common operations easy. Visual diffs supported.

RepoWatch (Mac OS X)

  • RepoWatch (homepage) is a graphical client for Mac OS X that provides very quick access to the basics of Git or Mercurial with minimal effort: just press Command-Option-Enter.

Sprout (formerly GitMac) (Mac OS X)

  • Sprout (homepage) Sprout is an App for Mac OSX that focuses on being a fast, user-friendly Git client. For developers who are new to Git, transitioning from Subversion, or just want a nice Mac UI alternative. Focuses on browsing and managing repositories and branches, and making common operations easy.

tig (Text-mode Interface for Git)

  • tig (homepage) by Jonas Fonseca is a simple git repository browser written using ncurses. Basically, it just acts as a front-end for `git-log` and `git-show`/`git-diff`. Additionally, you can also use it as a pager for git commands.


  • QGit (homepage) is a Qt GUI for browsing the history of Git repositories. It also acts as a commit tool, like (h)gct and as a graphical interface to StGIT. There is an experimental version of QGit ported under Qt4.2 libraries, available at This means that it could be compiled and run as a Windows native application.


  • Giggle (homepage) is a graphical frontend for browsing history of Git repositories (think of gitk on GTK+). Result of a Hackathon 2007, later developed by Imendio's Carlos Garnacho and Sven Herzberg and then by Mathias Hasselmann. Currently maintained by the GNOME community. Available from

gitview (in `contrib/`)

  • GitView is a GTK based repository browser for git written in Python by Aneesh Kumar K.V. It can be found in `contrib/` directory of Git source tree.


  • git-forest (git-forest file and manpage) is a text-based tree visualizer, using Unicode characters for tree graphics. Part of its key features are: display of tags, heads and other refs (like gitk), constantly vertical branch graphics (allows to follow a branch with the mouse easily), display of octopus merges. It can also display history in reverse.

A screenshot may be found at git-forest.png. Written in Perl by Jan Engelhardt.
See also: text-based tree visualizer announcement on git mailing list.


  • GitForce (homepage, github) by Goran Devic is a git frontend GUI for both Windows and Linux. It is in active development.


  • GitJungle ([2]) is a graphical branch explorer displaying branch history horizontally instead of vertically as most git graphical tools do. It shows merge links, commits, tags and branches and displays diffs when clicking on a specific commit. It runs on Windows, MacOS X and Linux. It is free and requires Mono to run.


  • Qct (hg repo) by Steve Borho is Qt/PyQt based GUI commit tool, meant to be SCM and platform agnostic. Supports Mercurial (`hg`), Bazaar (`bzr`), Cogito (but not Git directly atm), Subversion (`svn`), Monotone (`mnt`) and CVS. The README mentions gct (also on this page), as an alternative supporting plain git.


  • git-cola (github, homepage, gitweb) by David Aguilar is an advanced git commit tool, similar to git-gui, written in PyQt4. git-cola features a graphical 2D history viewer, easy, interactive partial-diff staging, inotify support, and more. You can get tarballs at Native packages exist for Debian, Fedora, and Arch. Mac OSX and Windows builds are available on the website.


  • teamGit ( by Abhijit Bhopatkar is a successor of kgit. It is intended to be a complete development workflow management app with git as a base tool. As of oct 2008 it can be used as a pretty good commit tool. Please see feature table below.


  • GitX (homepage, github, download) by Pieter de Bie, Germán Laullón and others is a gitk clone aiming to provide a more native interface to MacOS X users with OS X-only features. It has a native interface and tries to integrate with the operating system as good as possible. Examples of this are drag and drop support and QuickLook support.
    See also: GitX v0.1: Gitk clone for OS X post on git mailing list.


  • pyrite by Govind Salinas is a Git GUI and front end written in Python.


  • gitSafe (homepage) by cmroanirgo is a SourceSafe-like GUI for git using MFC. NOTE: This software is Closed Source.

Git Extensions

  • Git Extensions (github) is a toolkit for Windows users. The main feature is a shell extension that enables a context menu in Windows Exlorer to use most Git functions. The toolkit also contains a standalone GUI and a Visual Studio 2005/2008 plugin. The toolkit is mainly written in C#, the shell extensions code is written in C++. The toolkit is still under development, there is a beta version downloadable here:
    See also: Announcement: Git Extensions stable (windows shell extensions) on git mailing list.


  • TortoiseGit (gitweb) by Li Frank is a port of TortoiseSVN to Git. It is Microsoft Windows Explorer extension, written in C++. As of February 2011 TortoiseGit is at version and implements most regular tasks such as commit, show log, diff two versions, create branches and tags, create patches etc. It is not yet complete but well worth a try.

Dreamweaver GIT (GITWeaver Dreamweaver Tortoise Extension)

  • GITWeaver by Chris McKee is an Adobe Dreamweaver (MX->CS5) extension that adds TortoiseGIT functionality to Adobe Dreamweaver. Windows Compatible


  • git-cheetah is a cross platform filemanager plugin. It was started as a Windows explorer extension so the standard gui tools (namely Git Gui, Gitk History, Git Gui Blame) of git would be available from the filemanager. It has been ported to Mac OS X (Finder before 10.6) and Gnome Nautilus. Written completely in C, it has a simple infrastructure ready to add more plugin implementations. You can find the repository at


  • gitg (gitg) by Jesse van den Kieboom is a clone of GitX for gtk+/GNOME. As such it tries to follow the implementation of GitX closely, while providing tight integration into the GNOME desktop.


  • git-age is a `git blame` visualizer, written using PyGTK. Shows the file with information on author, commit etc on each line. Also colors the background of the line darker for older commits and lighter for newer commits. Useful for quickly seeing what parts of a file have changed recently. Will also attempt to retrieve Gravatars for all authors in the file asynchronously.

Qt Creator

  • Qt Creator is a lightweight, cross-platform integrated development environment (IDE) for developing with Qt that provides a built in GUI for working with Git repositories.


  • RabbitVCS is a set of graphical tools written to provide simple and straightforward access to the version control systems you use. Currently, it is integrated into the Nautilus file manager and supports Git (0.14 Beta 1) and Subversion, but the goal is to incorporate other version control systems as well as other file managers. Runs on Linux.


  • SmartGit by Syntevo GmbH is a graphical Git client which runs on all major platforms (e.g. Linux, Mac OS X, Microsoft Windows). It requires (SUN-) Java 1.5 or newer as well as a Git installation. Closed source, free of charge for non-commercial usage.


  • StupidGit by Ákos Gyimesi is a cross-platform git GUI written in wxPython. It tries to be easy to use for beginners and has advanced support for submodules. It is quite early in development, but already implements many features including merge, cherry-pick and easy switching between versions.


  • Gource is a software version control visualization tool. Software projects are displayed by Gource as an animated tree with the root directory of the project at its centre. Directories appear as branches with files as leaves. Developers can be seen working on the tree at the times they contributed to the project.


  • PyjamasGitWeb (git clone is two projects in one: a JSONRPC web service which uses python-git to serve git repository information, and a matching front-end as a pyjamas application. Pyjamas can run the front-end either compiled to javascript to run in a web browser or as a Desktop application (pure python). Cacheing of answers to queries is performed (in the browser or in the desktop app) so that any file or git link previously clicked on will come up instantly. Demo is at


  • SourceTree is a fast and friendly GUI for Git and Mercurial for Mac OS X 10.6+ (closed source, commercial). A trial version is available.

Agit (Android)

  • Agit is Git client for Android with features like pull-to-refresh fetching, periodic sync, and gently animated diff transitions. It's the first ever Git client targeted at mobile phone, and currently is a 'read-only' client, supporting clone & fetch, but not commit and push.

Summary (feature matrix)

gitk git-gui tig QGit Giggle gitview git-forest gct pmpu Qct git-cola GitNub GitX Pyrite gitSafe teamGit Git Extensions TortoiseGit gitg SmartGit StupidGit SourceTree Agit
written in Tcl Tcl C C++ C Python Perl Python Python Python Python ObjC, Ruby ObjC Python C++ C++ C#, C++ C++ C Java Python ObjC Java
UI toolkit Tk Tk curses Qt GTK+ GTK+ - Qt Qt4 Qt Qt4 Cocoa Cocoa  ? MFC Qt4 - MFC GTK+ Swing wxWidgets Cocoa Android
Open Source yes yes yes yes  ? yes yes  ?  ? yes yes  ? yes  ? no  ? yes yes yes  ?  ? no yes
last activity 2008 2008 2008 2008 2009 2006 2008 2007 2008 2008 2011 2008 2008 2008 2008 2008 2011 2011 2010 2009 2009 2010 2011
tree view X ext X X X X X ext X X X Explore X X X
history viewer X X X X X X X X X X  ? X X X X X X X X X
history search X X X X X X X  ? X X X X X X
(un)stage files X X X X  ? X X X X X X X
partial staging X X X X X X X X
undo diff fragments X
checkout X X X X X  ? X X X X X X X X X
cherry-pick X X X X  ? X X X X X X
committing X X X X X X X X X  ? X X X X X X X X
remote features X X X X  ? some X X some some X
stash X  ? X X X X X X
format patch X X X X X  ? X X X X
interfaces w/ external diff viewers X X X X X X
diff +/- highlighting X X X X X X X X X X X X X X X X X
compare commits X X X X  ? X X X X X
merge features X X  ?  ? X X X X X X
inotify support X
interactive rebase  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ? X X
apply patches via drag'n'drop  ?  ?  ?  ?  ?  ?  ?  ? X  ?  ?  ?  ? X X
i18n de, es, it, sv de, fr, hu, it, ja, ru, sv, zh_cn ca, de, en_GB, es, fr, ja, pl, sv, vi partial de, fr, hu, it, ja, ru, sv, zh_cn
Screenshot X X X X X X X (gct) X X X X X (Pyrite) X X X X X X X X X

Deprecated and stalled projects

(h)gct (deprecated)

  • (h)gct (gitweb) by Fredrik Kuivinen is a GUI enabled commit tool. It has support for both Git and Mercurial. In Debian in commit-tool package. Written in PyQt. Does not support git 1.6 and higher.

gitool (deprecated)

  • gitool (announcement, download, gitweb) by Paul Mackerras is a tool for creating commits. Superseded by git-gui (see above). Last development activity in 2007. Written in Tcl/Tk.

GitNub (stalled)

  • GitNub (homepage, github) by Justin Palmer is an Mac OSX Leopard client for git written in Ruby and Objective-C.

KGit (deprecated)

  • KGit ( by Abhijit Bhopatkar is intended to be a small but functional frontend to the popular source control program, git. It is similar to gitk with two significant differences. First of all, it is written in Qt using lop and the KDE libraries. Secondly, it is not only a repository viewer, unlike gitk. It is now defunct and deprecated by the author. Has no future.

Push Me Pull You (stalled)

  • pmpu (Push Me Pull You) by Mark Williamson is a graphical interface for a distributed version control system. Currently it contains proof-of-concept supports the Mercurial, git and bzr systems. PMPU can make use of external history views and commit tools. Preview release. As of November '09, no developer activity for more than 1 year.

Web Interfaces

gitweb (distributed with Git)


  • GitList is an elegant and modern web interface for interacting with multiple git repositories. It allows you to browse repositories using your favorite browser, viewing files under different revisions, commit history, diffs. It also generates RSS feeds for each repository, allowing you to stay up-to-date with the latest changes anytime, anywhere. GitList was written in PHP, on top of the Silex microframework and powered by the Twig template engine. This means that GitList is easy to install and easy to customize. Also, the GitList gorgeous interface was made possible due to Bootstrap.


  • klaus (Demo) is a standalone, zero-configuration-required Git viewer written in Python (WSGI) that ships with a minimalist but elegant Web interface inspired by GitHub. klaus is developed by Jonas Haag.

WebGit .NET

  • WebGit .NET IIS Hosting for Git "Smart HTTP" using ASP.NET MVC. It is written in C# and is hosted on Aimed at internal hosting of Git repositories in a windows environment, it supports syntax highlighting via SHJS and post-create hooks.


  • Gitorious provides free open source infrastructure for open source projects that use Git. Open Source and Ruby on Rails based.


  • InDefero is a clone of GoogleCode with git, Mercurial and Subversion browser, wiki, download area, issue tracking and code review supporting multiple private/public projects. Using a shared user account with SSH keys you can control the read/write access rights to your repositories from within the web interface. GNU GPL/Clean MVC PHP5 code, very fast and easy to extend. Download, view source. Free hosting also available.


  • Wit ( is a Ruby/eRuby web interface to git that provides much easier setup, configuration, maintainability, and customizability than gitweb, all in fewer lines of code and with a prettier interface. It is (barely) maintained by Daniel Chokola.

wit (defunct?)

  • wit (download) is a Python implementation maintained by Christian Meder. Uses PATH_INFO URLs extensively. See it in work here.



  • ginatra (github, demo) is web interface written in Ruby using Sinatra web framework.


  • git-php is a PHP git web frontend created by Zack Bartel. The goal of git-php is a robust PHP web interface to git repositories. It is meant to be easily customizable through styles and the ability to be embedded into any PHP page. For example, creating a git repository viewer plug-in for your favorite PHP based CMS should be easy with git-php. It seems to be inspired by gitweb. See it at work at
  • is a PHP git web frontend created by Peeter Vois. This is continued work of Zack's version of git.php. git-php does now have syntax highlighting of code, graph view of the repository including branch and tag, diff can be browsed against several parent versions, tree browser does have some nice icons, simple search for branch heads and tags, any version of tree can be downloaded in tar.gz or zip format and the filename will include hash of the tree or tag if attached, files can be downloaded independently in binary form. Git php is providing interface for sending bundles to the owner of the site. This is useful for those who would like to stay anonymous or do not like to send bundles via e-mail. The bundle is also tested against the repository before acceptance.
  • is a PHP git web frontend created by Jose Diaz-Gonzalez. Contains updates to Peeter Vois and Zack Bartel's work that adds a github-like stylesheet, as well as fixes for the latest updates to git syntax. It is also an attempt to ameliorate the differences between gitweb and all other gitweb derivatives with git-php.


  • GitPHP (demo) is a PHP git web interface with gitweb-like look (the xmms2 fork of git), created by Christopher Han. It makes use of Smarty templates, so it can be easily modified and customized. It offers syntax highlighting via GeSHi PHP class, has support for snapshots and projects categories; it can be run with msysGit.


  • viewgit is another PHP web interface for git, written from scratch. It aims to be easy to set up and upgrade, light on dependencies, and comfortable to use. It provides all basic features such as commitdiffs, RSS feeds of changes, downloading of trees, checkouts, syntax highlighting using GeSHi, etc.




  • GitStat (SourceForge project) is a GPL'd, web-based git statistics/monitoring system. It retrieves a specified git tree, analyzes changesets, and shows graphical information like the number of changesets per day, the number of people who submitted changesets for a specific version (tag) etc. Users may subscribe to gitstat so that they automatically receive an email notification if any change is applied to a specified directory. See also gitstat 0.1: kernel development statistics / monitoring system announcement on git mailing list. You are welcome to try gitstat at


  • GitStats - with a 's', not the same as GitStat - (SourceForge project) is a statistics generator for git repositories. It examines the repository and produces some interesting statistics from the history. Currently it outputs only HTML. As opposed to GitStat, it generates the HTML statically, and is therefore suitable to generate pages to upload to a dumb HTTP server. Some examples are available.


  • All Links Dead 2010/11/05. git-browser by Arteem Khodush is an experimental gitk-like web interface. It visualizes commit history graph and shows commit diffs. User interface is done in JavaScript, and is rather heavy on the client side. view online download gitweb mirror.


  • pitweb by Daniel Fiser is a web interface for git repositories written in python and licensed under LGPL.


  • PyjamasGitWeb (git clone is two projects in one: a JSONRPC web service which uses python-git to serve git repository information, and a matching front-end as a pyjamas application. Pyjamas can run the front-end either compiled to javascript to run in a web browser or as a Desktop application (pure python). Cacheing of answers to queries is performed (in the browser or in the desktop app) so that any file or git link previously clicked on will come up instantly. Demo is at written in python and licensed under LGPL.

Git Enablement Server (G.E.S.)

  • Git Enablement Server is a combination of Git SmartHTTP server (git_http_backend replacement) and a web interface for consuming and browsing filesystem trees sprinkled with git repositories.
  • The front-end is entirely JavaScript (Single page, Sammy.js-based) that talks to server (Python, WSGI-based git_http_backend replacement + JSONRPC server supporting calls from Web client).
  • The server is targeting Personal, Small Team use cases. The goal of the project is to make an absurdly simple-to-install-and-use *private* collaboration server.
  • Install is just "git clone URI", "git submodule init", "git submodule update --recursive". In it's simplest form, the server is set-up and started just by double-clicking the executable. As of Nov 25, 2010, is tested to work equally well on Linux and Windows. To run, requires only two things: Python and command-line git executable.


  • git2html generates a set of static HTML pages for exploring a git repository. Because the pages are static, no CGI script is required to explore the repository. This makes git2html more secure and robust than other web viewers. Due to the decision to use static html, git2html is also less flexible, for instance, it does not support showing a diff between arbitrary revisions.

git webcommit

  • git webcommit A webbased committool with very few little requiments. Written in PHP, uses git commandline tool for writing to the repository. Useful for example when people want to keep track of changes when collaborating on a website.


  • Grack (github) aims to replace the builtin git-http-backend CGI handler distributed with C Git with a Rack application. This reason for doing this is to allow far more webservers to be able to handle Git smart http requests.


Access control / Project hosting

gitosis (unmaintained ?)


  • SCuMD (gitweb, by Mike 'gaffo' Gaffney is a tool provide access to git repositories over SSH, with pluggable access controls and without the need for shell accounts or the normal ssh daemon exposed. (Java, require java 1.6)


  • ssh_acl by Bruno Ribas is a set of bash scripts which can be used to manage Git repositories access.


  • gitolite (, by Sitaram Chamarty, (sitaramc at gmail), is inspired by gitosis, plus an urgent need to manage per-branch permissions. It is written entirely in perl, and designed to be usable on any Unix machine that managed to install git and perl. It does not require root access to install or use.
  • Other advantages: an "easy install" script + copious documentation to make things as painless as possible, especially with the critical ssh pieces; simpler, yet more powerful config file syntax; ability to split the config into parts and delegate authority to different people; better logging helps figure out exactly what was allowed/denied and why; "personal" branch namespace for developers. Also there's a version that allows "deny" in the access control list, making it truly powerful for pretty much all sorts of access restriction needs


  • girocco ( by Petr Baudis is a Git project hosting framework, powering e.g. the hosting site. It supports project forking, both mirror and push project modes, is highly configurable and flexible, but contains just the essential features. It is suitable both for public hosting and intranet Git hosting sites for developers' cooperation within closed shops.


  • SCM-Manager ( by Sebastian Sdorra is a java webapplication to create and manage git, mercurial and subversion repositories. SCM-Manager allows easy access to the repositories over the http or https protocol.


  • Gitblit (github, Google code) is an open-source, pure Java stack for managing, viewing, and serving Git repositories (based on JGit). It's designed primarily as a tool for small workgroups who want to host centralized repositories. Gitblit is available in two variations:
    • Gitblit GO - a complete & integrated pure Java stack
    • Gitblit WAR - a traditional WAR distribution

(Java, requires Java 6 Runtime Environment (JRE) or a Java 6 Development Kit (JDK))

Filesystem interfaces

git fs

  • git fs A fuse filesystem for browsing git commits and past worktrees.


  • figfs A fuse interface to git, with editable workspace support.


  • GitFS is a FUSE-based filesystem for working with source trees stored in git repositories. The eventual goal is to provide a convenient way to work with lots of branches and patches. Currently (pre-release version 0.03) only very basic functionality is implemented - read-only access to the existing tags and objects.

Inferno filesystem translator

  • gitfs (inferno) A git filesystem translator for inferno, a portable plan9.


  • git-fuse-perl by Marco Fontani. A simplistic attempt to provide a FUSE read-write interface to a Git repository. Requires perl-fuse.


Editors and IDE integration

Emacs integration (in contrib/)

  • Preliminary Emacs mode for Git from Alexandre Julliard (in contrib/emacs directory) consist of `git.el` which is project tree browser similar to pcl-cvs, and vc-git.el which is VC backend (see also vc-git-hacking at gnuvola).
    There is also a project, DVC (Distributed Version Control), on Gna!, by the authors of Xtla, to create a generic library for fancy Emacs interfaces to modern version control systems. Currently it supports GNU Arch (tla) and Bazaar (baz), and has initial support for Bazaar-NG (bzr) and Mercurial (xhg).
  • Magit is an alternative git mode for Emacs. Unlike the standard Emacs vc mode (git.el) it can take full advantage of git specific features.
  • See also: EmacsWiki:Git and EmacsWiki:Category:VersionControl pages on EmacsWiki

Ecilpse plugin (EGit)

JetBrains IDEs: IntelliJ IDEA 9.0 / PyCharm 1.0 / RubyMine / etc.


  • The Git4Idea plugin provides basic Git integration support for the IntelliJ/JetBrains IDEA (v6 & above) development environment. The Git4Idea plugin can be downloaded from within IDEA itself using the IDE Settings->Plugins config panel. The plugin home page contains the latest release information and source code is also available here. Git4Idea uses the git command line tool to work; Cygwin 'git' on Windows is recommended.


NetBeans plugin

  • NetBeans comes with Git support out of the box. Also see: NetBeansPlugin


  • Padre-Plugin-Git provides basic Git integration for Padre, a text editor being developed as an IDE for Perl.


  • PIDA Integrated development environment supporting GIT, Subversion, Darcs, Mercurial, Monotone, Bazaar-NG (bzr). It allows embedding Vim or emacs. (Python, GTK)


  • Git-tmBundle Provides a variety of tools for interacting with Git repositories, such as push, pull, tag, fetch, browse annotations, merge, switching branches, stashing, committing, etc. (Ruby)


  • VCS Command plugin is a Vim plugin for various source code control systems and includes a Git component. It can be used to view the differences side by side, commit, blame, etc.
  • fugitive.vim is a Vim plugin with lots of features, for example: View any blob, tree, commit, or tag in the repository with :Gedit ... Edit a file in the index and write to it to stage the changes. Use :Gdiff to bring up the staged version of the file side by side with the working tree version and use Vim's diff handling capabilities to stage a subset of the file's changes. ... :Gblame brings up an interactive vertical split with git blame output.i :Gmove does a git mv on a file and simultaneously renames the buffer. :Gremove does a git rm on a file and simultaneously deletes the buffer. Use :Ggrep to search the work tree (or any arbitrary commit) with git grep, ... :Glog loads all previous revisions of a file into the quickfix list so you can iterate over them and watch the file evolve! Use :Gbrowse to open the current file on GitHub... and much more.
  • gitv is a 'gitk clone' plugin for the text editor Vim. The goal is to give you a similar set of functionality as a repository viewer. Using this plugin you can view a repository's history including branching and merging, you can see which commits refs point to. You can quickly and easily view what changed to which files and when. You can perform arbitrary diffs (using Vim's excellent built in diff functionality) and you can easily check out whole commits and branches or just individual files if need be.

Visual Studio

  • Git Source Control Provider provides source control integration in Visual Studio 2008/2010 solution explorer through the standard interfaces.
  • Git Extensions. See Graphical Interfaces above or website for details.

Merge tools


  • Diffuse is a graphical tool for merging and comparing text files. Diffuse is able to compare an arbitrary number of files side-by-side and gives users the ability to manually adjust line-matching and directly edit files. Diffuse can also retrieve revisions of files from Bazaar, CVS, Darcs, Git, Mercurial, Monotone, Subversion, and SVK repositories for comparison and merging.


  • dirdiff (gitweb) is a graphical tool to display the differences (a la diff) between files in directories. Given two or more directory trees, dirdiff will display the differences between them in various glorious colors. It provides merging and the creation of patches. Link is to version modified by Sven Verdoolaege, which adds some more git support, and which is based on dirdiff-2.1.tar.gz by Paul Mackerras. Not actively developed. In Tcl/Tk. (To be not confused with dirdiff in Perl).


  • Meld is a visual diff and merge tool. You can compare two or three files and edit them in place (diffs update dynamically). You can compare two or three folders and launch file comparisons. You can browse and view a working copy from popular version control systems such as Git, CVS, Subversion, Bazaar-ng and Mercurial, etc...


  • Kdiff3 is a graphical tool for merging and comparing text files. Kdiff3 is able to compare two or three files side-by-side and gives users the the ability to specify directories of files. Works on KDE/Linux, any UNIX or Linux that supports Qt and MS Windows (there is also a version for OS/X)

Per-file merge drivers


  • The estimable Bruno Haible wrote a merge driver for ChangeLog files. The driver currently lives in the gnulib sources.

Interaction with other Revision Control Systems

Multiple Systems

Built-in import (built in)

  • Core Git contains import commands for importing from other systems: `git-archimport` for GNU Arch (`tla`), `git-cvsimport` for CVS (needs `cvsps`: CVSps patches), `git-svn` for Subversion (`svn`) (using `SVN::Perl` module), `git-quiltimport` for Quilt, and `git-p4` for Perforce (`p4`). For Quilt see also quilt2git / git2guilt below. For Perforce import there is also a script using alternative import method, which works without changing local state: git-p4-import. There also exists a (dumb and slow) unpublished BitKeeper (`bk`) importer.


  • Tailor is an any-to-any version control system converter, with support for most free SCMs. It was written by Lele and it is implemented in Python. Note that you need VersionOne. Note also that as of 2006-12-01, it only has rudimentary support for branches, and mostly supports linear histories.


git-cvsexportcommit (built in)

  • `git-cvsexportcommit` exports a commit from Git to a CVS checkout, making it easier to merge patches from a git repository into a CVS repository. Supports file additions, removals, and commits that affect binary files.

git-cvsserver (built in)

  • `git-cvsserver` is a CVS emulation layer for git. It is highly functional; the mapping is bidirectional, so people who like cvs, can do both checkout and commit using cvs, and it shows up in git. However, not all methods are implemented, and for those methods that are implemented, not all switches are implemented. Testing has been done using both the CLI CVS client, and the Eclipse CVS plugin. Most functionality works fine with both of these clients.


  • parsecvs by Keith Packard is a C-based CVS file parser and Git import tool. It directly reads RCS ,v files (you can get them using CVSsuck if you don't have access to $CVSROOT) and generates a git-style rev-list structure from them. Repository available at git://


  • cvs2svn has a cvs2git mode for converting directly from CVS to git. cvs2svn/cvs2git is very robust and gives high-quality conversions with many features and customization options. cvs2svn/cvs2git only supports one-time conversions. cvs2git's output can be read by Shawn Pearce's git-fast-import, which has been bundled with core Git since version 1.5.
    Note that cvs2svn/cvs2git itself can't work with remote repositories. If you can't get a copy of the CVS repository directly, you might be able to recreate it indirectly via information read over the CVS protocol using a tool like CVSsuck.


  • fromcvs by Simon 'corecode' Schubert is a conversion tool ment convert from CVS to multiple SCMs. At the moment there is a git and a hg output and a sqlite output for quick CVS changeset navigation. For the cvs->git conversion, git-fast-import by Shawn Pearce is needed (see above). fromcvs handles branches (though no tags yet), including native support for vendor branches. Incremental operation is supported. Conversion speed should be well above 10 changesets per second on common hardware. fromcvs/togit can take advantage of two CPUs.


  • gc-utils (freshmeat page, gitweb, announcement) is a small set of scripts wrapping git-cvsexportcommit and git-cvsimport, allowing to import and update CVS repositories into git very easy and let you export patches back into a CVS working copy. Written in bash.


git-svn (built in)

  • git-svn (git repository), written by Eric Wong, is a conduit for bidirectional operation between a Subversion repository and git. It supports Subversion branches and tags, importing multiple Subversion repositories into a single git repository, and incrementally updating the git repository with changes from the Subversion parent. It is designed for developers who wish to contribute to projects that use Subversion, but would rather be using git. Written in Perl using the SVN::Core Perl library.
    See also: git-svn-bugfix script

git-svnimport (contrib)

  • There is also git-svnimport, and because it came earlier it is mentioned often in old documentation. At the moment (August, 2008), git-svn is better supported.

git2svn (perl/bash)

  • git2svn, written by Paul Miller, is a git repo exporter designed to allow a user to import numerous git repos into a trac wiki. Trac only supports svn (natively) and only supports a one repo configuration. Although there are git plugins for Trac, they are cumbersome and (because of trac's design) only support one repo at a time. git2svn solves that by importing as many git repos as needed into directories of an svn repo. It does this using native svn and git commands with perl as glue.

git2svn (fast-export)

  • git2svn (gitweb), written by Love Hrnquist strand, is a tool to convert the "git fast-export" dump into a svn dump and load it into a new fresh svn repository. git2svn also supports incremental updates. NOTE: git2svn assumes its the only process that writes into the svn repository. Written mainly in Perl.
    See: git2svn 0.1 post on git mailing list. (yet another one)

  • (gitweb), by Thomas Guyot-Sionnest, has been written to keep Nagios-plugins SVN tree updated from Git. It uses "git svn set-tree" to update the old subversion repository. Forced updated are possible (with manual intervention) as set-tree just apply a given snapshot with the last commit message. Under normal operation all commits are applied (not just the latest) and a "From:" line is inserted in the message to keep tracks of who committed what from SVN commit logs. (one-way, no rebase)

  • (github), by Martin Long, has been written to allow a one way sync to a subversion repository, without the need to rebase or write commit details back to the GIT repository. This makes is suitable for syncing a central or shared GIT repository to a SVN repo for backup, or to satisfy corporate/project requirements. The removal of the need to rebase prevents issues with downstream repositories. Works on multiple repositories, creating new branches in SVN automatically. For non-linear histories without a branch in tack, only the first-parent chain is committed.

  • (download), written by Neil Schemenauer, is a tool to do conversions from SVN (Subversion) to git using a SVN dump. It's in early stages of development. Written in Python.
    See: New converstion tool: thread on git mailing list

svn2git (Ruby)

  • svn2git (github), forked by Kevin Menard from James Coglan project, is a Ruby tool for importing existing svn projects into git and github. It uses git-svn.



  • svn-all-fast-export/svn2git (Gitorious) by Thiago Macieira, is a tool that exports from Subversion onto multiple Git repositories via git-fast-import. Written in C++, uses Qt Core library. It came into being to serve KDE's needs for a conversion to Git. It is reportedly faster than git-svn as of 2010-03-30: 8 minutes instead of 110 minutes on a multi-branch 15,5K revisions repository.


  • svneverever, written by Sebastian Pipping in Python, is a tool that helps understanding history of a subversion repository before migrating it to Git. It runs through all history collecting additions of directories. In the end it presents a tree of all directories ever having existed in the repository. This information is a good basis to writing rules files for svn-all-fast-export/svn2git. A more detailed introduction to svneverever can be found in the author's blog post Before svn2git you want to run: svneverever.


  • Braid (github), formerly Giston, is a Piston lookalike for git-svn: a simple tool to help track svn vendor branches in your git repository. By Cristi Balan, in Ruby (Piston is in Ruby).


  • GIT sub-project porcelain that provides an alternative to git-svn dcommit when managing rails vendor plugins which are held in a central SVN repository. Currently git-svn is not able to dcommit into a Subversion repository when a Git repository contains submodules. git-rails-plugins is an alternative implementation to sub-modules.



  • hg-to-git is Mercurial to git converter, written by Stelian Pop, appeared only on git mailing list in post Mercurial to git converter. It supports incremental conversion, supports (multiple) hg branches and converts hg tags. Written in combination of shell script and Python.


  • hg-fast-export is another converter using `git-fast-import` as backend and is written in Python using the mercurial python classes directly. It uses a single pass, supports tags, mercurial named branches, incremental imports and merges. It is quite fast since no subshells and/or pipe communication is used except for the feed to `git-fast-import`. The source is available as part of the fast-export repository at




  • Having had problems with darcs2git and tailor, Steve Purcell wrote another simple darcs import tool called darcs-to-git, which can incrementally import a single darcs source repo: article / darcs-to-git gitweb



  • A generic fast-export script for darcs by Miklos Vajna, works with git fast-import, bzr fast-import and hg fastimport. Find it at here.




  • Git-bzr allows bidirectional synchronization between Bazaar and Git repositories, much like git-svn. However, git-bzr is able to keep all merge history etc. Ruby original can be found at github (port to shell script: mcepl, kfish).



  • A shell script that migrates a Bazaar repository to Git, written by Henrik Nilsson and can be found here.


git-p4 (built in)


  • The script `` in `contrib/p4import` may not work anymore and is left for reference only.


  • The project `git-p4raw` can import an entire p4 depot faithfully, preserving branch relationships. It uses the p4d database files directly. See the github repo.



  • A Ruby script that imports Monotone repositories with different modes of operation; checkout and fast-import. Depending on the method is the completeness and reliability: checkout method is almost complete. It also allows further updates. Find it at github.



  • git-cc is a simple bridge between Clearcase and Git. It supports both base ClearCase and UCM. In case of base ClearCase, per-file histories are merged based on commit messages and timestamps. Incremental bi-directional synchronization is supported.

CC2GIT ClearCase GIT Bridge (Clearvision)

  • Complete Integration between IBM Rational ClearCase and Git from Clearvision. The CC2Git Bridge allows developers to quickly and easily transport code between the two tools, enabling one continuous integrated SCCM environment with the reduced costs associated with open source software. Looking to Migrate; the CC2Git bridge allows companies to perform a controlled migration within longer timescales, learning and resolving dependencies as they arise, using live data but without affecting project teams.
    Read More on our website:

git-ucmimport (IBM Rational ClearCase)


quilt2git / git2quilt

  • These utilities convert patch series in a quilt repository and commit series in git back and forth. You can download files here; they can be found on HomeTJ webpage.

SCCS import

  • There exists proposed `conftib/fast-import/` in fast importer for SCCS files post by James Youngman on git mailing list, and sccs2git-gfi importer by Sam Vilain in VCS::SCCS CPAN module.


  • rcs-fast-export (gitweb) is a Ruby script that can be used to export RCS histories in a form suitable to be piped to fast-import tools (only tested with git's). It parses RCS files directly, without requiring any external tool or library. It exports symbols as lightweight tags, and makes up a decently sensible name for branches, based on their initial revision number. It supports the typical `--authors-file` option to convert from usernames to full author identities, and it has an option to (lightweight) tag each RCS revision with its revision number.


  • rcs-fast-import (freshmeat) by Eric S. Raymond is a tool that makes a valiant effort to stuff metadata from modern distributed version control systems back into RCS. It may be useful for extracting the revision histories of individual files from a project history. (Python).


vss2git (Visual Source Safe to Git)

  • vss2git is a tool written in C# to convert a Visual Source Safe repository into a Git one. It preserves deleted files and renames, and attempts to construct meaningful changesets based on chronologically grouping individual project/file revisions.

vss2git (Visual SourceSafe to GIT or SVN)

  • vss2git / vss2svn - tool (written in C++) converts Visual SourceSafe database to GIT / SVN repository. Does not use direct analysis of VSS database - simple cycle "ss get" "git/svn commit" is used. Deleted files are skipped during conversion process. File revisions are grouped by user but split by date. Only cpp & h files are converted (hardcoded but easy to edit). (6GB database 10 years development took ~4 hours to convert)

tfs2git (Team Foundation Server to Git)

  • tfs2git - Powershell script that converts Team Foundation Server repositories to a Git repository. Replays the history from the Team Foundation Server and adds it to a Git repository.

git-tfs (Team Foundation Server bridge)

  • git-tfs is a two-way bridge between TFS and git, similar to git-svn. You need .NET 4 and either the 2008 or 2010 version of Team Explorer installed.



  • git-notify is the post-receive hook used by the wine project. It sends one email per commit. It also supports sending cia notifications.


  • git-commit-notifier is the post-receive hook used by lot of projects. It sends HTML email commit messages splitting commits that were pushed in one step. Changes are highlighted per word.


  • archive-tag is a post-receive/update hook developed by and formerly used by the Aegir project to ease maintenance of tarballs associated with a git repository. Archives (and optionally checksums) are created when tags are pushed to a repository. This is part of Koumbit's git-hooks project.


  • git-blacklist is an update hook which allows a multi-user centralized repository to block known-bad commits and refs from being pushed.

Hooks for integration with IBM Rational Team Concert

  • The following article shows several ways other SCM systems can be used in conjunction with Rational Team Concert 2.x. The main focus of this article is how the integration of Git and IBM Rational Team Concert work items can be achieved using Git hooks.


CIA is a system for tracking open-source project commits in real-time. It needs a script installed as a post-commit or update hook to send git log summary messages to the CIA server,

  • The Version 3 ciabot scripts, and, have been rewritten to work well with git version 1.6.0 and later. Use unless your hosting site forbids Python hooks; the shell version is more likely to break due to not being able to call out to utilities it needs.
  • These scripts evolved by translation from by Petr Baudis in the `contrib/` directory of Cogito. The ancestral Perl is somewhat fragile and may fail with newer git versions, although has a fixed version in their git hooks project. This is the "version 2" script, still written in Perl and still kicking.

The Version 3 scripts are part of git contrib/ as of 2010-04-02.

The advantage of the version 3 scripts are that they are a full rewrite in Python, however they do not support XMLRPC anymore and force you to include a URL in the IRC output, optionnally wrapped with tinyurl, which some people may not want.

The advantage of the version 2 script is that it does not do talk to tinyurl (but they don't support gitweb links) and it has XMLRPC support.


Gitspread solves the problem of pushing to several remotes or mirrors over a slow connection, for example a mobile connection from a laptop. By using a hook/daemon setup on a server with a fast connection, commits and branches are automatically spread to many mirrors by pushing only once to that repository.

Source code mirrors: Gitorious,

Wikis, blogs, etc.



  • Gollum is a simple, Git-powered wiki with a sweet API and local frontend. It is the wiki engine of github.





  • Nuki (github) by Patrick Thomson is a Wiki engine written in Nu and powered by Nunja (github), a cross-platform web server that's scripted with Nu, that uses Git for version control, and Markdown (via NuMarkdown) for markup.


  • git-blog (github) is a minimalist blogware that uses git, using Ruby to 'deploy' Markdown posts to XHTML when git-pushed to your server.


  • Tekuti is weblog software written in Scheme, using Git as its persistent store. It uses WikiPedia:SXML for markup, and requires Guile or other Scheme implementation, and mod_lisp (a bit of misnomer: it is similar to WikiPedia:FastCGI or SCGI that it creates long-lived CGI process, but with simpler protocol). Tekuti includes a script to import posts from Wordpress into a suitably-laid-out directory.
    Announcement: I'm telling you on Andy Wingo wingolog.


  • Chuyen is a weblog software written in Python, using the django web framework and git as its data storage backend through pygit. It uses ReStructuredText as its markup language.


  • eWiki is a Wiki with a git backend, written in pure PHP (no ugly system() or exec() calls).


  • Pystl (gitweb) by Jack Miller is very simple, small blog engine in Python, using git for version control, Markdown for markup and Tenjin for templating. It doesn't have web interface, so it also have no comments.


  • gitit, a Wiki written in Haskell, uses git for storage, HAppS for a web server, and pandoc for markdown processing.


  • Shinmun (github) by Matthias Georgi is small git-based blog engine written in Ruby. Write posts in your favorite editor, `git-push` it and serve your blog straight from a repository. Supports Markdown, Textile or HTML files.


  • OddmuseGit, two bash scripts to interface between git and the Oddmuse wiki. Handy for merging multiple Wikis or having distributed Oddmuse wikis without changing the existing backend.

Levitation (export Wikipedia page history into a Git repository)

  • Levitation is a project to convert Wikipedia database dumps into Git repositories. It has been successfully tested with a small Wiki ( having 12,200 articles and 104,000 revisions. Seems to have stalled.


  • Blawd is a blogging engine written in Perl for generating simple blogs from markdown files stored in Git repositories. It is successfully used in a couple different blogs in the Perl community. It is based upon Moose and Git::PurePerl.

Bug/issue trackers, etc.


  • Ditz is a simple, light-weight distributed issue tracker designed to work with distributed version control systems like darcs and git. Ditz maintains an issue database file on disk, written in a line-based and human-editable format. This file is kept under version control, alongside project code. Changes in issue state is handled by version control like code change: included as part of a commit, merged with changes from other developers, conflict-resolved in the standard manner, etc.


  • TicGit is a distributed bug tracker written in Ruby. It stores bug information in a separate branch, allowing multiple developers to control the bug tracking system by merging their ticgit branch.


  • git-issues is a distributed issue tracking system based on Git repositories, written as standalone Python script. One can check this script in along with project in order to ensure that all contributors are able to view the bug database using the same version of the script that was used to create them. Originally a rewrite of ticgit in Python. (Python)


  • CIL - Command-line Issue List (written in Perl), allows fast creation of a distributed issue tracker which fits in well with any VCS.
    See also: Blog posts tagged 'cil' on


  • milli is a simple bug tracking system, written in Perl, which allows you to store reported bugs within your projects. To allow easy sharing of bugs the system will create a .milli/ directory beneath your project, containing a single text file for each bug. The intention is that you'll add the .milli directory to your revision control system, so that anybody who can currently checkout, view, or commit updates may also do the same with bug reports. (Perl)

Bugs Everywhere

  • Bugs Everywhere is a distributed bugtracker, designed to complement distributed revision control systems. It uses distributed revision control as a backend for bug state. Supported version control backends: Arch, Bazaar, Darcs, Git, Mercurial, Monotone. (Python)

SD (Simple Defects)

  • SD (Simple Defects) is a peer-to-peer bug tracker that’s built for sharing and use both online and offline. With SD, you can sync your bugs back and forth between other instances of SD, and even between SD and other bug trackers that SD supports (RT, Hiveminder, Trac, GitHub Issues, Google Code, Redmine). Git and Darcs VCS integration. (Perl)


Gerrit Code Review

codeBeamer Collaborative ALM Solution

  • codeBeamer - (free trial at JavaForge) Award winning collaborative ALM solution with wiki, document management, highly customizable issue tracking, continuous integration, version control with Git (and Mercurial, Subversion, etc.), source code analysis, forums and more.


Jira Git plugin


  • git-bugzilla (gitweb, manpage) by Steve Frcinaux, is a tool to post (attach) patches to Bugzilla, modelled mostly after `git-format-patch`/`git-send-email`. It is written in Perl and requires WWW::Mechanize


  • git-bz (script, cgit) is a command-line tool for using git with bugzilla. You can file commits (in git-format-patch format) as new bugs, attach them to existing bugs, or apply patches attached to bugs to your working tree. It has some neat features like rewriting the commit to include the URL to the newly filed bug before attaching it to the bug. git-bz is a self-contained Python script that acts as a git subcommand and has no external dependencies other than git.


  • scm-bug ( is a generic glue between VCS systems (git, svn and cvs in 0-26-21) and bug-tracking software (bugzilla, mantis, request tracker and test director in 0-26-21). It provides features such as notifying the bugtracker when a related commit is done, optional workflow-enforcing checks, version description document generation. Written in perl.

IBM Rational Team Concert

  • The following article shows several ways other SCM systems can be used in conjunction with Rational Team Concert 2.x. The main focus of this article is how the integration of Git and IBM Rational Team Concert work items can be achieved using Git hooks.

Backups, metadata, and large files


  • bup (github) by Avery Pennarun is software that can efficiently backup large amounts of data (hundreds of GB) across large numbers of files (millions), using a git-formatted repository as storage. It also efficiently stores huge individual files, such as virtual machine disks, and can backup directly to a remote machine rather than using space on the local machine. A FUSE module is included so you can mount your backup repository as a filesystem and restore files that way.
    See also: Bup: it backs things up blog post (and comments).


  • git-annex allows git to track files whose content should be tracked out-of-band some other way. This is useful when dealing with files larger than git can currently easily handle, whether due to limitations in memory, checksumming time, or disk space. Annexed files can co-exist in the same git repository with regularly versioned files, which is convenient for maintaining documents, Makefiles, etc that are associated with annexed files but that benefit from full revision control.


  • Chronoversion is a simple Python script which attempts to use the git content tracker to provide chronological snapshots similar to Plan 9's venti filesystem. The two differences are that, being based on git, it isn't a filesystem in the sense of needing kernel support to gain access to the data (so it can be used on systems where you can only install userspace programs) and it allows programmatic decisions about what to snapshot, rather than recording everything into the snapshot. By David Tweed. It can be downloaded (at least currently) from chronoversion.tgz.


  • Metastore (gitweb) by David Hardeman is a tool which allows the metadata to be stored in a separate file which can be stored along with the rest of the data in the repo (or separately). This is also useful for tripwire type checks and for other types of storage which drops some of the metadata (tar comes to mind).
    Repository: git://



  • etckeeper (gitweb, announcement) by Joey Hess is a collection of tools to let /etc be stored in a git repository. It hooks into apt to automatically commit changes made to /etc during package upgrades. It used to use metastore but now uses a script to track file metadata that git does not normally support, but that is important for /etc, such as the permissions of /etc/shadow. It's quite modular and configurable, while also being simple to use if you understand the basics of working with git.
    See also: IsiSetup




  • SparkleShare is a collaboration and sharing tool. It aims to be simple to use. Written in Mono/C#.


  • Persy is a file synchronization and backup tool. Very focused on Ubuntu users.

Other tools

  • by René Moser [3] is a simple shell script for doing FTP the Git way. Use to upload only the Git tracked files to a FTP server, which have changed since the last upload. This saves time and bandwith. Even if you play with different branches, knows which files are different. No ordinary FTP client can do that.


  • git-ftp ([4]) by Edward Z. Yang is a simple script written in python for uploading files in a Git repository via FTP, only transferring new files and removing old files.


  • by Paul Miller is a Perl script that replays git commits into an svn repo for the purpose of showing changes in packages like Trac, which only understand svn natively, without the need for special plugins. It is probably not useful for anything besides listing changes for packages like Trac. GSR differs from git-svn, which is used for bi-directional commits. GSR works hard to preserve commit times and re-formats commit messages in a way that's nicer for Trac to display.


  • git2rss by Bennett Todd is a Perl script to generate an RSS summary of a git repo. Currently to be used rather as example. Similar to darcs2rss.


  • git2cl (gitweb) by Simon Josefsson is a Perl script to convert git logs to GNU ChangeLog format. The tool expects output from git --pretty --numstat --summary on standard input. Inspired by cvs2cl tool. References: ANNOUNCE: git2cl message on git mailing list.
  • See also alternate solution: New script: git-changelog.perl - revised by Ronald Landheer-Cieslak, with slightly different output, less dependencies, and being standalone command and not a filter.

git status-report

  • git status-report (announcement, github) by Kate Rhodes (masukomi) is a script (in Ruby) that outputs a bullet list of all your commits for the past n days, or the commits of one of your fellow contributors from any number of branches and repos. Useful to put together a status report for boss.

git-completion.bash (in `contrib/completion`)

  • Bash tab-completion shipped with core Git. Inspired by and superceeds the tab-completion provided by gitcompletion (see below). Completion support is provided for almost all commands, including completion of local and remote reference names and long command line options.

gitcompletion and generate-completions


  • Gitdm (the "git data miner") (gitweb, mirror) is the tool that Greg KH and Jonathan Corbet have used to crank out statistics on where kernel patches come from at LWM (configuration files, tar.bz2). Public repository for gitdm can be found at: git://


  • git-what-branch by Seth Robertson allows you to perform forensics investigation to discover the merge-path a particular commit took in getting to any named branch or user specified object.

log remapper

  • remapper (gitweb, snapshots) by Al Viro, announced in Re: |RFC| Add "rcs format diff" support, is a tool to (re)map position (file name and line number) in one revision to corresponding position (file name and line number) in other revision. E.g. user sends report "linux-2.6.16 with configuration XYZZY fails to compile with: arch/wii/kernel/l33t.c:42:parse error" and with the remap tool you can map the error report to the current commit's state, when that bit of code got moved around to `drivers/input/wii/l33tcontrol.c:31337`. It also already very useful for log comparison, with the noise due to line number changes excluded. Note that it's not just for build logs; the thing is useful for sparse logs, grep -n output, etc., etc.
    See also: Kernel space: Buried in warnings article at



  • gitcharts (github) by Tomasz Dąbrowski (dabroz) is a small C# app that generates a graph for lines of code in a given git repository over time, and supports multiple projects in one repository.


  • pepper is a scriptable repository statistics tool with support for Git. It ships with many common reports, including LOC and activity graphs generated using the built-in Gnuplot API.



  • reposurgeon ([5]) is as an editing tool for repository histories that will work with any version-control system supporting import and export of git fast-import streams. It supportes editing old comments and metadata, removing commits, fixing timezones, coalescing single-file commits, and other tricky operations. It can be very helpful in cleaning up cruft from repository conversions.

git_fast_filter and git-rewrite-commits

  • git_fast_filter (gitorious) by Elijah Newren assists with quickly rewriting the history of a repository by making it easy to write scripts whose purpose is to serve as safe filters between fast-export and fast-import. git_fast_filter comes with example programs,and a basic test-suite.
    See announcement on git mailing list and the following thread.
  • git-rewrite-commits by Sven Verdoolaege is an alternate interface to git-filter-branch-like functionality (more similar to cg-admin-rewritehist from Cogito). It is available from git mailing list archives fro PATCH 0/6| Add git-rewrite-commits v2 thread.


  • git timetrack is a new git command that allows management of project time dedication by attaching a time-spent note per commit with minimal extra effort for the developers, providing then advanced querying of the dedicated time.


  • gitco by Simon Josefsson is a tiny shell script to remove unversioned files from git directories, similar to cvsutils 'cvsco' or subversion's svn-clean. It basically calls the standard git clean and git reset --hard commands.


  • setuptools_git (formerly gitlsfiles) is Git plugin for Setuptools, by Yannick Gingras (Python). Setuptools is a collection of enhancements to the Python distutils that allow you to more easily build and distribute Python packages, especially ones that have dependencies on other packages.


  • git-now is a new git command. It create temp commits. The commits' messages include time-stamp and diff.


  • git-buildpackage is a tool for managing the debian packaging of an application in git. Documentation. There are other solutions and suggestions for debian packaging and git, for example see GitSrc.


  • Gear is a tool for building RPM packages from git repositories.


  • 0release can be used to make new releases of your software. It handles details such as setting the version number and release date, tagging the release in GIT, exporting, running any unit-tests, uploading the archive, pushing the tag, and updating your Zero Install feed. The workflow is: run the script (creates a tarball), do any manual release testing, then either publish everything or fail the release (reverting to your repository's previous state ready to make changes and try again). Only two user interactions are required: starting the script and confirming the generated release.


  • ./ is a simple mechanism to create and tag release branches on a remote (centralized/blessed) git repository. Alpha-quality. Does not have any "server-side" hooks to actually do something with the releases or method to simplify tracking new release branches. (Do not confuse this with the "build recipes" in msysGit.)


  • Ryppl is a a cross-platform package management system designed to accomodate both end-users and developers. Unlike a traditional package manager, which delivers binaries and/or a source snapshot, when ryppl downloads a package, it gives you a clone of a Git repository, with that package's entire development history. It also pulls down the correct versions of any repositories on which the requested repository depends. If you're an ordinary end-user, the fact that they are git repositories may be invisible to you, but if you're a developer, it means you're already prepared to work on the package, keep track of your changes, and submit them to the official maintainer(s).
  • Ryppl includes facilities for building, testing, and installing packages on the local machine. However, it also has integrated support for remote testing. That is, you can arrange that tests be run on build slaves located “out there” on the internet. This allows developers to discover portability issues without having direct access to every build platform.


  • fedora-packager is a collection of tools for Fedora developers and includes fedpkg which is specifically for managing Fedora packages within Fedora's git based package repository. Fedpkg thinly wraps common git commands such as clone, commit, pull/push, etc...


  • metagit is a tool for defining sets of git (or whatever scm) repositories and perform actions like clone/pull/push on them. It is possible to list repositories on a remote site, e.g. find all repositories in a directory via ssh. The original annoucement is here



  • gitslave by Seth Robertson creates a group of related repositories all of which are concurrently developed on and on which all git operations should operate, so when you branch, each repository in the project is branched in turn. Similarly when you commit, push, pull, merge, tag, checkout, status, log, etc; each git command will run on the superproject and all slave repositories in turn.


  • gitbuilder (github, demo) by Avery Pennarun is a set of relatively simple scripts for automatically building git-hosted project, optionally running unit tests, and reporting pass/fail results. In case of failures, it automatically uses git-bisect(1) to try to track down the first commit that started failing. It's also smart about branches; it knows how to build each commit only once, no matter how many branches include it, thus greatly simplifying future bisections.
    See also: Announce: gitbuilder, an autobuilder for git-based projects post on git mailing list.


  • bbchop (github) by Ealdwulf Wuffinga is a tool for bisecting on an intermittent bug, using Bayesian decision theory.


Nico Schottelius scripts

William Morgan git tools

  • William's miscellaneous git tools include git-wtf, a tool for working with feature branches (and its precursor git-show-merges), git-publish-branch to ease the task of "publishing" a branch (mostly superseded by git push -u <origin> <branch>), and git-rank-contributors which ranks all the contributors by the size of their diffs (as opposed to git shortlog --numbered --summary which counts number of commits). By William Morgan and Jeff Balogh (Ruby)


  • git-central (github) by Stephen Haberman is a small collections of hooks, scripts, and practices (documentation) for use with a centralized (non-distributed/corporate) git repo. Those include: svn-like revision numbers, combined diff-enabled commit emails, Hudson hooks, Trac hooks, branch locking, etc.


  • git-diffall (github) by Tim Henigan is a script which performs a directory diff on a complete git repo using an external diff utility specified by the user. This script is compatible with all the forms used to specify a range of revisions to git diff.


  • git-blameall (website) Shows every line that was ever in the file, along with information about when it was added or deleted.


  • git-edit-index by Bert Wesarg is a tool which lets you edit files directly from the index, without changing the working copy. The temporary file sits next to the original file, and the index will be updated with the new content (including file mode).


  • git-build by Bert Wesarg is a tool which records the output from an arbitrary command, but also the state of the working directory (including untracked but not ignored files) the start directory used and the exit status of the command by creating a commit of these and storing it in a special ref refs/builds/default. The commit message is the command. The author date is set to the start date and the committer date to that of the end date of the command. The reflog is used to automatically discard old records. My main intention is to use this for builds, such as ./configure && make && make check. Thats why this is called git-build, and also to have a command history by using the reflog. Dumping the environment at command start is on my TODO. Any other hints what should be recored is welcomed.


  • git-mklinks by Bert Wesarg is a tool which creates hard links for all files with the same content and file mode in the work tree.

See also

Personal tools