Interfaces, frontends, and tools

From Git SCM Wiki
(Difference between revisions)
Jump to: navigation, search
(Wikis, blogs, etc.)
Line 1,113: Line 1,113:
=== OddmuseGit ===
=== OddmuseGit ===
* [ 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.
* [ 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.
== Bug/issue trackers, etc. ==
== Bug/issue trackers, etc. ==

Revision as of 12:23, 13 April 2010


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://`

Interfaces to other programming languages


  • 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).


  • 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. Git repository is available here.


  • 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 ca be found at git:// and its gitweb here.

PyGit (abandoned?)

  • Pythonic git bindings targeted towards porcelains. There is also the "stores" branch that implements pack and object reading natively in Python.


  • 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 seperate 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)

  • Ruby/Git (github) is a Ruby library that can be used to create, read and manipulate Git repositories. Unmaintained, abandoned in favor of mentioned above Grit.

Objective Git

  • 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 (Java)

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

dotGit (inactive?)

  • dotGit 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# (GitSharp)

  • Git# 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.

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.


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

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.

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. As of November '09, no developper activity for nearly 6 months.


  • 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. Currently maintained by Mathias Hasselmann. Available from As of November '09, no developper activity for more than 6 months.

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.


  • 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 (gitweb, github) by David Aguilar is a git commit tool, similar to git-gui, written in PyQt4. You can get tarballs at Native packages exist for Debian, Fedora, and Arch. Mac OSX and Windows binaries are available on the website.


  • teamGit ( by Abhijit Bhopatkar is a successor of kgit. It is intended to be a complete developmenet 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 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 2010 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.
    See also: TortoiseGit Challenge on GitHub.


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

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.


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

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
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
UI toolkit Tk Tk curses Qt GTK+ GTK+ - Qt Qt4 Qt Qt4 Cocoa Cocoa  ? MFC Qt4 - MFC GTK+ Swing wxWidgets
Open Source yes yes yes yes  ? yes yes  ?  ? yes yes  ? yes  ? no  ?  ?  ? yes  ?  ?
last activity 2008 2008 2008 2008 2009 2006 2008 2007 2008 2008 2010 2008 2008 2008 2008 2008 2009 2009 2010 2009 2009
tree view X ext X X X X X ext X X X Explore X X
history viewer 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
(un)stage files X X X X  ? X X X X X X
partial staging X X X X X X X
undo diff fragments X
checkout 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
remote features X X X X  ? some X X some some
stash X  ? X X X X X X
format patch X X X X X  ? X X X
interfaces w/ external diff viewers X X X X X
diff +/- highlighting 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
merge features X X  ?  ? X X X X X
inotify support X
interactive rebase  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ? X
apply patches via drag'n'drop  ?  ?  ?  ?  ?  ?  ?  ? 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

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 libraires. 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 developper activity for more than 1 year.

Web Interface

gitweb (distributed with Git)


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


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

Filesystem interfaces

  • git fs A fuse filesystem for browsing git commits and past worktrees.
  • figfs A fuse interface to git, with editable workspace support.
  • gitfs (fuse) The first fuse interface to git.
  • gitfs (inferno) A git filesystem translator for inferno, a portable plan9.


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).
  • See also: EmacsWiki:Git and EmacsWiki:Category:VersionControl pages on EmacsWiki

Ecilpse plugin (EGit)


  • 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 module (nbgit)

  • A NetBeansPlugin with a limited set of features are available for testing.


  • 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.
  • Other Vim tips

Visual Studio

  • 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 conffused 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...

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-p4import` 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 should work, but was not yet tested extensively. 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 commited what from SVN commit logs.

  • (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 mecurial 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 and git-p4-import (Perforce)

  • The built-in Perforce importer `` does not work and is not being actively developed. A replacement, `git-p4` by Simon Hausmann, is now in contrib/fast-import and is highly recommended. See also Yet another git perforce integration thread on git mailing list. There is also an older Perl version, `git-p4-import` by Alex Riesen: see Yet another Perforce importer email/thread on git mailing list.



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


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.


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)



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


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


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

Wikis, blogs, etc.






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


  • ymcGitWiki is a wiki software written in PHP, using eZ Components and git as its data storage backend. It can use ReStructuredText as well as different Wiki syntaxes 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.

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.


  • 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


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.

Other tools


  • 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-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


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.

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


  • 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://


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


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

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




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


  • 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 programatic 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 uses metastore 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



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


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


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



  • SCuMD (gitweb, by Mike 'gaffo' Gaffney is a tool provide access to git repositories over SSH, with pluggable access controls and withouth 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.



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


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


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

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


  • 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.)


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


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.



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


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


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

See also

(Related Tools)

Personal tools