Interfaces, frontends, and tools

From Git SCM Wiki
(Redirected from InterfacesFrontendsAndTools)
Jump to: navigation, search

Contents


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.

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

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

darcs-git

  • darcs-git.py (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.

repo

vng

Zit

  • 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://git.oblomov.eu/zit`

fgit

  • 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

C

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

Perl

  • 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 Git.pm does.

Python

  • 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://git.samba.org/jelmer/dulwich.git and its gitweb here.
  • Pygit2 is a set of Python bindings to libgit2 (see above).
  • 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.
  • vcs is Various Control System abstraction layer written in Python. Uses mix of already mentioned Dulwich and Git binary for the Git backend. Provides simple yet fully featured interface and is under heavy development stage.

Ruby

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

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 the Git mailing list.

PHP

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

Haskell

  • hlibgit2 is a complete, FFI level wrapper around libgit2.
  • gitlib is an abstraction of the Git "model", allowing the use of many different backends, including forking command-line Git and hlibgit2.
  • 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).

JavaScript

  • 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 repository API for accessing repos available via HTTP.

Patch-management Interface layers

StGIT (Stacked Git)

  • StGIT (homepage, tutorial, gitweb) 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, howto, manpage, 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

  • 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

  • TopGit (GitHub) is a patch management interface done as a set of shell scripts, which can be used to manage a set of third-party patches on top of another project. It is a very thin layer on top of Git (allowing you to use the index); it attempts to keep all history of your changes until final cleanup; and it allows you to specify patch dependencies instead of linearizing patches in a patch series (patch queue).
    See also: TopGit - A different patch queue manager announcement on the 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

Git Watcher

  • Git Watcher [1] is a multi-platform desktop app that shows real-time diff file information for working directory and index and allows you to commit/push changes. It also organizes submodules in tabs and has many other options and tools. Currently in development!

Cocoon

  • Cocoon [2] is a KDE 4 playground project to create a GUI for Git.

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 ([3]) 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 OS X 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

  • QGit (homepage) is a Qt GUI for browsing the history of Git repositories. It can also act as a commit tool, a file annotation and modification history browser, and as a graphical interface to StGIT. The sources for the latest, 2.5 version are available at http://repo.or.cz/w/qgit4/redivivus.git. This version compiles with Qt4 and is directly portable to Linux, Windows and MacOS.

CodeReview

  • CodeReview (homepage) is a Qt GUI written in Python for browsing the history of Git repositories and show a side-by-side diff of the changes similar to kdiff. It is a clone of the QBzr diff tool. It is thus a local code review tool and not a complete GUI for git. It should work on Linux, Windows and MacOS.

Giggle

  • 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 http://git.gnome.org/browse/giggle/

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 (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 the Git mailing list.

GitForce

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

GitJungle

  • GitJungle ([4]) 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

  • Qct (Mercurial repository) 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

  • 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 http://cola.tuxfamily.org/. Native packages exist for Debian, Fedora, and Arch. Mac OSX and Windows builds are available on the website.

teamGit

  • teamGit (http://www.devslashzero.com/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

  • 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 the Git mailing list.

Pyrite

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

gitSafe

  • 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: http://code.google.com/p/gitextensions/
    See also: Announcement: Git Extensions stable (windows shell extensions) on the Git mailing list.

TortoiseGit

  • TortoiseGit (gitweb) by Li Frank is a port of TortoiseSVN to Git. It is Microsoft Windows Explorer extension, written in C++. As of June 2014, TortoiseGit is at version 1.8.9.0 and implements a full set of git tasks such as create, browse and clone repositories, pull, commit, push, show log, diff two versions, create branches and tags, create patches etc.

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

  • 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 http://repo.or.cz/w/git-cheetah.git.

gitg

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • PyjamasGitWeb (git clone gitolite@pyjs.org:pyjamasgitweb) 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 http://pyjs.org/pygit

SourceTree

  • SourceTree is a fast and friendly GUI for Git and Mercurial for Mac OS X 10.6+ and Windows 7+ (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.

Working Copy (iOS)

  • Working Copy is a full-featured Git client for iOS. It supports cloning, fetching, committing, pushing and merging. Using iOS app extensions it provides read/write access to repositories from other applications.

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 Working Copy
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, C++ Java ObjC
UI toolkit Tk Tk curses Qt GTK+ GTK+ - Qt Qt4 Qt Qt4 Cocoa Cocoa  ? MFC Qt4 - MFC GTK+ Swing wxWidgets Cocoa Android UIKit
Open Source yes yes yes yes  ? yes yes  ?  ? yes yes  ? yes  ? no  ? yes yes yes  ?  ? no yes no
last activity 2008 2008 2008 2008 2009 2006 2008 2007 2008 2008 2011 2008 2008 2008 2008 2008 2011 2014 2010 2009 2009 2015 2011 2016
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 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 X
undo diff fragments X X
checkout X 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 X
remote features X X X X  ? some X X some some X 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 X
compare commits X X X X  ? X X X X X
merge features X X  ?  ? X X X X X X X
inotify support X
interactive rebase  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ?  ? X 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 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 (http://kgit.sourceforge.net/) 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

gitlabhq

  • GitLabHQ is a fast, secure and stable solution based on Rails & Gitolite. Free and open-source. Distributed under the MIT License.


gitweb (distributed with Git)

GitList

  • 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

  • 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 Github.com. Aimed at internal hosting of Git repositories in a windows environment, it supports syntax highlighting via SHJS and post-create hooks.

Gitorious

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

InDefero

  • 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

  • Wit (http://github.com/dchokola/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.

gitarella

ginatra

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

git-php

  • 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.
  • http://people.proekspert.ee/peeter/git/git.php 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.
  • http://github.com/josegonzalez/git-php 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

  • 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

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

cgit

Gitalist

GitStat

  • 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 http://tree.celinuxforum.org/gitstat

GitStats

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

  • Git Treemap generates an animated treemap representation of a repository or a subdirectory thereof. Git Treemap offers three distinct views, which either provide an overview of each file's size, recent commits, or recent commits introduced by any specific author. The webpage is generated statically, much like with GitStats.


git-browser

  • 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

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

PyjamasGitWeb

  • PyjamasGitWeb (git clone gitolite@pyjs.org:pyjamasgitweb) 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 http://pyjs.org/pygit 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

  • 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 web-based checkout status viewer and commit tool. Useful for example when people want to keep track of changes when collaborating on a website that is tracked in Git, especially if some participants are not command-line savvy. Written in PHP and has very few requirements. Uses the git command-line tool for staging changes to the index and writing commits to the repository.

Grack

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

Git-Webby

pgkiss

  • (pgkiss) is a very simple PHP wrapper for "git http-backend"-CGI script. It enables hosting of Git repositories on a web server with just PHP and Git available. Currently relies on web-server provided authentication if (or when) such is needed.

Access control / Project hosting

gitosis (unmaintained ?)

SCuMD

  • 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

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

gitolite

  • gitolite (http://github.com/sitaramc/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

  • girocco (http://repo.or.cz/w/girocco.git) by Petr Baudis is a Git project hosting framework, powering e.g. the repo.or.cz 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

  • SCM-Manager (http://www.scm-manager.org) 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. It has centralized user, group and permission management and is completely configurable from within the web interface.
  • By using SCM-Managers plugin API it is possible to automate various tasks. There is already a couple of plugins available, such as:
    • JIRA (enables you to close issues out of your IDE)
    • notify (the plugin sends automated messages to a list of subscribed addresses whenever a repo has changes)
    • LDAP

SCM-Manager Universe

  • SCM-Manager Universe ([5]) by TRIOLOGY is an Ubuntu Linux based virtual machine, which comes with a bundle of ready to use open source software components for software development, including
    • SCM-Manager
    • Jenkins
    • Sonatype Nexus
    • SonarQube
    • Bugzilla
  • The appliance is free and open source software and distributed under BSD-License.
  • It has a comprehensive documentation, including tutorials, a sample project and tool descriptions.
  • All of the software development tools authenticate over Single Sign-On against a central LDAP server with reasonable default users and groups configuration.
  • The appliance has also a simple backup mechanism, which allows regular backups of all relevant files.
  • TRIOLOGY is offereing a free update service and commercial support.

Gitblit

  • 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 JDK) or up)

GitBucket

  • GitBucket ([6]) is an easily installable Github clone powered by Scala with user management (LDAP).

Filesystem interfaces

git fs

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

figfs

  • figfs A fuse interface to Git, with editable workspace support written in OCaml; related university site; inactive since 2009

GitFS (from mitch at sfgoth.com (Mitchell Blank Jr))

  • GitFS (via archive.org) 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. (dead since 2006?)

GitFS (Python)

  • GitFS declared pre-alpha

Inferno filesystem translator

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

git-fuse-perl

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

gitfuse

git-fs

  • git-fs, written in C, Patrick Haller

gitfs

Tools

Editors and IDE integration

Emacs integration

  • Preliminary Emacs mode for Git from Alexandre Julliard (in contrib/emacs directory) consist of `git.el` which is a project tree browser similar to pcl-cvs, and vc-git.el which is a VC backend (see also vc-git-hacking at gnuvola).
  • 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. Supports TopGit and StGit (see above).
  • See also: EmacsWiki:Git and EmacsWiki:Category:VersionControl pages on EmacsWiki

Eclipse plugin (EGit)

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

Git4Idea

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

KDevelop

NetBeans plugin

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

Padre

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

PIDA

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

TextMate

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

Vim

  • 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 <code>git mv</code> on a file and simultaneously renames the buffer. :Gremove does a <code>git rm</code> on a file and simultaneously deletes the buffer. Use :Ggrep to search the work tree (or any arbitrary commit) with <code>git grep</code>, ... :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

imerge

  • git-imerge is an open-source tool that helps you perform difficult Git merges and rebases by allowing conflicts to be resolved incrementally.

Diffuse

  • 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

  • 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

  • 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

  • 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

git-merge-changelog

  • 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

You may find the DVCS Migration Guide a useful resource if you are attempting to migrate a project history to Git.

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.

reposurgeon

  • reposurgeon is a repository-editing tool supporting multiple VCSes including CVS, Subversion, Git, Mercurial, Bazaar, darcs, and SRC. It can import to Git from any of the VCSes it supports, and export from Git to all supported VCSes. It actually speaks Git import streams natively and relies on fast-import/fast-export tools to talk to most other VCSes; the exception is Subversion dump streams, for which it also has native read/write support.

Tailor

  • 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 2012-12-09, it only has rudimentary support for branches, and mostly supports linear histories. Development effectively ceased years ago, making it unlikely these deficiencies will be repaired.

CVS

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.

cvsps

  • Warning: this code has been end-of-lifed by its maintainer in favor of cvs-fast-export. Several attempts over the space of a year to repair its deficient branch analysis and tag assignment have failed. Do not use it unless you are converting a strictly linear repository and cannot get rsync/ssh read access to the repo masters. If you must use it, be prepared to inspect and manually correct the history using reposurgeon.
  • The 3.0 version of cvsps has gained a --fast-export option that emits a Git fast-import stream. You can feed this directly to Git fast-import. CVS tags become Git lightweight tags. Branching is detected and handled. Merges are not, but you can easily fix those up with reposurgeon (which uses cvs-fast-export as its CVS-reading front end).

cvs-fast-export

  • cvs-fast-export (originally by Keith Packard as parsecvs) is a CVS file parser and Git import tool. It directly reads RCS ,v files and generates a Git-style fast-import-stream. reposurgeon uses this to read CVS repositories. Branching and tags are fully supported. It can process above 200 commits per second on common hardware. An auxiliary tool, cvssync, mirrors CVS repositories so cvs-fast-export can see the masters locally. A wrapper, cvsconvert, both drives the conversion and checks the history against CVS to verify correctness.

cvs2git

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

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

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

Bigitr

  • Bigitr Bidirectional, asymmetric synchronization between Git and CVS, across multiple branches. Synchronizes full states, not patches. Uses reserved branches in Git to represent state of CVS. Intended to allow development to move to Git in cases where processes have been implemented around CVS. Can push Git to CVS, pull from CVS into Git, or both. Does not use git-cvsimport or git-cvsexportcommit. Can be used with a repository initially created using git-cvsimport to preserve earlier history. It is configuration-driven, and can run arbitrary programs as hooks at many points in the process. Has built-in error reporting through email. Logs all Git and CVS operations, including output and error, and logs all diffs. Honors local CVS and Git configuration.

CvsntGitImporter

  • CvsGitImporter is a front-end to fast-import for CVSNT. It uses the features of CVSNT to construct accurate commits and merges between branches, as well as importing tags and branches. It is able to reorder and split commits where necessary to cope with cases where tags have been moved around (within reason). Written in C#.

Subversion

When choosing git migration tools you need to clearly grasp the difference between an gateway (supporting live operation on a Subversion repository through git) and an importer (designed to move an entire Subversion history to git). The programs in this section were usually designed for one of these purposes and may have serious hidden flaws if used for the other.

Importers and gateways are listed first, then exporters, then auxiliary tools. See git-svn on how to use Git as an Subversion client. Here is a feature matrix of the production-quality importers:

reposurgeon git-svn svn2git SubGit agito
role? importer gateway importer gateway importer
handles branching? yes yes yes yes yes
makes annotated tags? yes no yes yes yes
splits mixed-branch commits? yes no no yes yes
makes .gitignore files? yes no no yes yes
documentation excellent good good excellent passable
written in Python Perl Ruby Java Python
last activity? 2015 2012 2012 2013 2012
maintainer Eric S. Raymond Eric Wong James Coglin, Kevin Menard TMate Software Simon Howard

reposurgeon

  • reposurgeon is especially useful for Subversion-to-git and CVS-to-git migrations. It reads Subversion dump files directly and both reads and writes Git fast-import streams. It also reads CVS repositories using git-fast-export as a front end. Unlike many other conversion tools, reposurgeon fully supports multibranch repositories, automatically converts svn:ignore properties into .gitignore files, and can even handle the pathological mixed-branch commits sometimes found in Subversion repositories. The surgical commands assist in cleaning up conversion artifacts; they are especially useful for large, old repositories that have been through previous conversions with tools like cvs2svn.

    If you are doing a full import rather than gatewaying, reposurgeon is probably what you want. It has been tested against a lot of large, old, nasty repositories and is thus known to be robust in the presence of repository malformations (a property regularly checked by a test suite that is a rogue's gallery of Subversion botches).

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.
  • SAFETY WARNING: While git-svn has been commonly used for one-time full conversions of Subversion histories to Git and could have been listed as both gateway and importer, it is a poor tool for importing. It doesn't make annotated tag objects from (unmodified) Subversion tag copies, nor does it handle mixed-branch commits properly. Worse, it sometimes silently produces conversions with correct head content but incorrect or damaged older revisions. Its is especially likely to do this if the repository was at one time in CVS and converted with cvs2svn, but can have other causes as well. See also: git-svn-bugfix script In general git-svn is liable to stumble badly on my kind of malformation in the SVN history, producing an amplification of it in the git translation. Use a better-quality importer like reposurgeon or agito instead.

svn2git (Ruby)

  • svn2git (GitHub), forked by Kevin Menard from James Coglan's project, is a Ruby tool for importing existing SVN projects into Git and GitHub. It uses git-svn; the major added feature is that it makes annotated Git tags from Subversion tag copies (however, it leaves the empty tag-copy commits in place). Be aware that as a wrapper for git-svn it inherits git-svn's tendency to stumble over repository malformations.

SubGit

  • SubGit is a tool for establishing bi-directional Git-SVN mirror of Subversion repository, developed by TMate Software. SubGit works on the server side as a set of hooks installed into Git and/or SVN repository. Every incoming modification sent to SubGit-enabled repository triggers these hooks, as result SubGit immediately converts incoming changes to Git or SVN correspondingly. SubGit is not based on git-svn, it uses proprietary translation engine written in Java. Being SVN to Git importer, SubGit converts arbitrary SVN branches and tags into Git branches and tags preserving all the history including meaningful merge-tracking data; it also converts svn:ignore properties to .gitignore files, svn:eol-style/svn:mime-type properties to .gitattributes files. SubGit can also be used as a Git to SVN exporter.
    See also: SubGit vs. git-svn comparison

agito

  • agito (GitHub) is a SVN-to-Git importer written by Simon Howard that behaves better than git-svn in handling tags on deleted and recreated branches. It replicates Subversion's default set of ignore properties with a .gitignore generated into the project root directory, but does not translate ignore properties explicitly set on individual Subversion directories.

git-svnconvert

svn-all-fast-export

  • svn-all-fast-export (Gitorious) by Thiago Macieira, is a tool that exports branches from Subversion onto multiple Git repositories via git-fast-import. Written in C++, it uses the 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.

braid

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

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

git2svn (Perl/Bash)

  • git2svn, written by Paul Miller, is a Git repository exporter designed to allow a user to import numerous Git repositories into a trac wiki. Trac only supports SVN (natively) and only supports a one-repository configuration. Although there are Git plugins for Trac, they are cumbersome and (because of trac's design) only support one repository at a time. git2svn solves that by importing as many Git repositories as needed into directories of an SVN repository. 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 the Git mailing list.

git2svn.pl (yet another one)

  • git2svn.pl (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.

svnExport.pl (one-way, no rebase)

  • svnExport.pl (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 repository 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.

svneverever

  • 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

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

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

git-svnsync

  • git-svnsync is a hook-based bi-directional server-side synchronisation tool between a git and a subversion repository. It is designed to allow a smooth transition of projects from a subversion repository to a git repository. Git-svnsync guarantees that any branch update ('svn commit' or 'git push') is applied atomically in both repositories, thus providing a seamless experience to the developers.
    • Unlike git-svn, it runs on the server and does not rebase commits. The developers can use the git repository normally (like any regular git repository), especially 'git merge' and 'git pull' are supported.
    • Compared to SubGit, it has a minimalist approach. The translation engine does not attempt to recreate the detailed non-linear history from git. Instead it creates only one svn commit for each git push. Consequently the accurate history is available only in the git repository and merge tracking is not interoperable (this means that merging must be made with git exclusively).

Mercurial

hg-to-git

  • hg-to-git is Mercurial-to-Git converter, written by Stelian Pop, appeared only on the 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

  • 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 repo.or.cz.

git-hg

Darcs

darcs-to-git

  • 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 repository: article / darcs-to-git gitweb

Darcs-Git

darcs-fast-export

  • A generic fast-export script for darcs by Miklos Vajna, works with Git fast-import, Bazaar fast-import and Mercurial fastimport. Vajna's original has disappeared, but a GitHub clone maintained by Brian Warner can be found here.

darcs2git

Bazaar

Git-bzr

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

bzr-fast-export

BzrToGit

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

Perforce

git-p4 (built in)

git-p4import

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

git-p4raw

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

Monotone

mtn2git

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

ClearCase

git-cc

  • 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: http://www.clearvision-cm.com

git-ucmimport (IBM Rational ClearCase)

Others

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/git-sccsimport.py` in fast importer for SCCS files post by James Youngman on the Git mailing list, and sccs2git-gfi importer by Sam Vilain in VCS::SCCS CPAN module.

rcs-fast-export

  • 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

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

rpm2git

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.

SRC

  • [http:://catb.org/~esr/src SRC] is a special-purpose VCS for single-file, single-developer projects by the author of reposurgeon and rcs-fast-import. It uses RCS as its storage engine but provides a Subversion-like CLI with integer monotonic-increasing revision numbers, lockless operation, embedded help, and many other convenience features. SRC includes both fast-export and fast-import commands for interchange with Git. Import is done through rcs-fast-import and has significant technical limitations.

Hooks

git-notify

  • 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

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

git-multimail

  • git-multimail is a post-receive hook for sending email notifications of pushes. It is a plug-in replacement for the post-receive-email script available from Git's contrib directory, except with bug fixes, more configuration options, and many new features, including a one-email-per-commit mode that threads commit emails by branch. It is easily extensible in Python.

archive-tag

  • archive-tag is a post-receive/update hook developed by Koumbit.org 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

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

CIAbot

Note: The CIA service died in September 2012 and is unlikely to be resurrected. See irker, below, for its replacement.

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, ciabot.py and ciabot.sh, have been rewritten to work well with Git version 1.6.0 and later. Use ciabot.py 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 ciabot.pl by Petr Baudis in the `contrib/` directory of Cogito. The ancestral Perl is somewhat fragile and may fail with newer Git versions, although Koumbit.org 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, but they 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 talk to tinyurl (but they don't support gitweb links)

irker

irker is a lightweight, decentralized replacement for the CIA service. It consists of two parts: a repository hook script, and a small service daemon that relays notifications to IRC servers. Unlike CIA, it doesn't have a single point of failure at a central server; rather, forge sites and major development hubs are expected to run their own irker instances which are privately accessible to local repository hooks. Git is well supported.

Gitspread

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: GitHub, Bitbucket, repo.or.cz

Wikis, blogs, etc.

ikiwiki

Gollum

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

wikiri

git-wiki

WiGit

Nuki

  • 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

  • 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

  • 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

  • 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

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

Pystl

  • 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

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

Shinmun

  • Shinmun (GitHub) by Matthias Georgi is a 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

  • 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 (bar.wikipedia.org) having 12,200 articles and 104,000 revisions. Seems to have stalled.

Blawd

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

Jekyll

Sputnik

Bug/issue trackers, etc.

Critic

  • Critic is web based code review tool based on Git. Reviews can be automatically created and updated by pushing changes to Git repository maintained by Critic. Reviewers can be assigned automatically based on users' preferences. Written in Python; stable and mature.

ditz

  • 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

  • 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

  • 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

  • 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 kapiti.geek.nz.

milli

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

git-cl

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.

BugTracker.NET

Jira Git plugin

git-bugzilla

  • 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

  • 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

  • scm-bug (http://www.mkgnu.net/scmbug) 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

  • 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

  • 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

  • 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

  • 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 repository (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://git.hardeman.nu/metastore.git (defunct?)
    active fork: github.com/przemoc/metastore

gitperms

etckeeper

  • 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

git-cache-meta

Flashbake

SparkleShare

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

Persy

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

Other tools

git gitlab-init

  • git gitlab-init by Quint Guvernator initializes a repository locally and remotely on Gitlab. It streamlines the process of making new repositories by removing a step that can't normally be done from the command-line.

gitdiffbinstat

  • gitdiffbinstat by Matthias Krüger is a Bash script to compare branches/commits/tags etc by actual file size. The script does also detect if a file has just been renamed. It will output a summary a bit similar to the way git diff --shortstat does it with line changes.

git-ftp.sh

  • git-ftp.sh by René Moser [8] is a simple shell script for doing FTP the Git way. Use git-ftp.sh 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, git-ftp.sh knows which files are different. No ordinary FTP client can do that.

git-ftp

  • git-ftp ([9]) 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.

git-svn-replay

  • http://search.cpan.org/perldoc?git-svn-replay by Paul Miller is a Perl script that replays Git commits into an SVN repository 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

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

git2cl

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

  • 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.lwn.net/gitdm.git

git-what-branch

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

ArcheoloGIT

gitcharts

  • 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

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

git-split

reposurgeon

  • reposurgeon ([10]) is 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. As of 2.0 it has the ability to read Subversion dump files directly, and is the best option for Git conversions of Subversion repositories with messy histories.

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 the 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 the Git mailing list archives fro PATCH 0/6| Add git-rewrite-commits v2 thread.

Timetrack

  • 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

  • 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

  • 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

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

git-buildpackage

  • 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

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

0release

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

./release.sh

  • ./release.sh 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

  • 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

  • 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

  • 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

git-subtree

gitslave

  • 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

  • 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 the Git mailing list.

bbchop

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

Parabuild

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

  • 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 repository. Those include: svn-like revision numbers, combined diff-enabled commit emails, Hudson hooks, Trac hooks, branch locking, etc.

git-diffall

  • git-diffall (GitHub) by Tim Henigan is a script which performs a directory diff on a complete Git repository 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 a Git diff.

git-blameall

  • 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

  • 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

  • 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

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

git-link

  • git-link constructs repository browser (ie. gitweb) urls of git objects.

git latexdiff

  • git latexdiff is a simple command that runs latexdiff to generate a visual diff of two versions of a LaTeX file (either two commits, or one commit against the work tree).

git-private-push

  • git-private-push by Marian Csontos (talk) allows creating a hidden branch in remote repository. Use git private-push to backup your work in progress branches, to keep history when frequently rebasing a branch without cluttering everyone's view, or to let others know the branch may get rebased at any time.
    WARNING: Hidden branches offers absolutely no security or privacy. They are just neither displayed nor fetched by default.

See also


Personal tools