Git (software)

From Wikipedia, the free encyclopedia - View original article

Git logo
Git session.png

A command line session showing repository creation, and addition of a file and remote synchronization
Original author(s)Linus Torvalds
Developer(s)Junio Hamano, Linus Torvalds, and many others
Initial release7 April 2005 (2005-04-07)
Stable release1.8.4.4 (20 November 2013; 12 days ago (2013-11-20)) [±][1]
Preview release1.8.5-rc3 (20 November 2013; 12 days ago (2013-11-20)) [±][2]
Written inC, Bourne Shell, Tcl, Perl[3]
Operating systemLinux, POSIX, Windows, OS X
TypeVersion control
LicenseGNU General Public License v2
Jump to: navigation, search
Git logo
Git session.png

A command line session showing repository creation, and addition of a file and remote synchronization
Original author(s)Linus Torvalds
Developer(s)Junio Hamano, Linus Torvalds, and many others
Initial release7 April 2005 (2005-04-07)
Stable release1.8.4.4 (20 November 2013; 12 days ago (2013-11-20)) [±][1]
Preview release1.8.5-rc3 (20 November 2013; 12 days ago (2013-11-20)) [±][2]
Written inC, Bourne Shell, Tcl, Perl[3]
Operating systemLinux, POSIX, Windows, OS X
TypeVersion control
LicenseGNU General Public License v2

In software development, Git /ɡɪt/ is a distributed revision control and source code management (SCM) system with an emphasis on speed.[4] Git was initially designed and developed by Linus Torvalds for Linux kernel development in 2005. Based on a recent survey of Eclipse IDE users, Git is reported to have 30% adoption as of 2013.[5]

Every Git working directory is a full-fledged repository with complete history and full version tracking capabilities, not dependent on network access or a central server.

Git is free software distributed under the terms of the GNU General Public License version 2.


Git development began after many developers of the Linux kernel chose to give up access to BitKeeper, a proprietary SCM system that had previously been used to maintain the project.[6] The copyright holder of BitKeeper, Larry McVoy, had withdrawn free use of the product after he claimed that Andrew Tridgell had reverse-engineered the BitKeeper protocols.

Torvalds wanted a distributed system that he could use like BitKeeper, but none of the available free systems met his needs, particularly in terms of performance. Torvalds took an example of an SCM system requiring thirty seconds to apply a patch and update all associated metadata, and noted that this would not scale to the needs of Linux kernel development, where syncing with fellow maintainers could require 250 such actions at a time. His goal was for patches to take three seconds.[7] Torvalds had several other design criteria:

These three criteria eliminated every then-existing version control system, except for Monotone. Considering performance as well excluded this too.[8] So, immediately after the 2.6.12-rc2 Linux kernel development release,[8] he set out to write his own.[8]

Torvalds has quipped about the name git, which is British English slang roughly equivalent to "unpleasant person". Torvalds said: "I'm an egotistical bastard, and I name all my projects after myself. First 'Linux', now 'git'."[10][11] The man page describes git as "the stupid content tracker".[12]

The development of Git began on 3 April 2005.[13] The project was announced on 6 April,[14] and became self-hosting as of 7 April.[13] The first merge of multiple branches was done on 18 April.[15] Torvalds achieved his performance goals; on 29 April, the nascent Git was benchmarked recording patches to the Linux kernel tree at the rate of 6.7 per second.[16] On 16 June, the kernel 2.6.12 release was managed by Git.[17] Torvalds turned over maintenance on 26 July 2005 to Junio Hamano, a major contributor to the project.[18] Hamano was responsible for the 1.0 release on 21 December 2005, and remains the project's maintainer.[19]


Git's design was inspired by BitKeeper and Monotone.[20][21] Git was originally designed as a low-level version control system engine on top of which others could write front ends, such as Cogito or StGIT.[21] However, the core Git project has since become a complete version control system that is usable directly.[22] While strongly influenced by BitKeeper, Torvalds deliberately attempted to avoid conventional approaches, leading to a unique design.[23]


Git's design is a synthesis of Torvalds's experience with Linux in maintaining a large distributed development project, along with his intimate knowledge of file system performance gained from the same project and the urgent need to produce a working system in short order. These influences led to the following implementation choices:

Strong support for non-linear development
Git supports rapid branching and merging, and includes specific tools for visualizing and navigating a non-linear development history. A core assumption in Git is that a change will be merged more often than it is written, as it is passed around various reviewers. Branches in git are very lightweight: A branch in git is only a reference to a single commit. With its parental commits, the full branch structure can be constructed.
Distributed development
Like Darcs, BitKeeper, Mercurial, SVK, Bazaar and Monotone, Git gives each developer a local copy of the entire development history, and changes are copied from one such repository to another. These changes are imported as additional development branches, and can be merged in the same way as a locally developed branch.
Compatibility with existing systems/protocols
Repositories can be published via HTTP, FTP, rsync, or a Git protocol over either a plain socket, ssh or HTTP. Git also has a CVS server emulation, which enables the use of existing CVS clients and IDE plugins to access Git repositories. Subversion and svk repositories can be used directly with git-svn.
Efficient handling of large projects
Torvalds has described Git as being very fast and scalable,[24] and performance tests done by Mozilla showed it was an order of magnitude faster than some version-control systems, and fetching version history from a locally stored repository can be one hundred times faster than fetching it from the remote server.[25]
Cryptographic authentication of history
The Git history is stored in such a way that the ID of a particular version (a commit in Git terms) depends upon the complete development history leading up to that commit. Once it is published, it is not possible to change the old versions without it being noticed. The structure is similar to a hash tree, but with additional data at the nodes as well as the leaves.[26] (Mercurial and Monotone also have this property.)
Toolkit-based design
Git was designed as a set of programs written in C, and a number of shell scripts that provide wrappers around those programs.[27] Although most of those scripts have since been rewritten in C for speed and portability, the design remains, and it is easy to chain the components together.[28]
Pluggable merge strategies
As part of its toolkit design, Git has a well-defined model of an incomplete merge, and it has multiple algorithms for completing it, culminating in telling the user that it is unable to complete the merge automatically and that manual editing is required.
Garbage accumulates unless collected
Aborting operations or backing out changes will leave useless dangling objects in the database. These are generally a small fraction of the continuously growing history of wanted objects. Git will automatically perform garbage collection when enough loose objects have been created in the repository. Garbage collection can be called explicitly using git gc --prune.[29]
Periodic explicit object packing
Git stores each newly created object as a separate file. Although individually compressed, this takes a great deal of space and is inefficient. This is solved by the use of packs that store a large number of objects in a single file (or network byte stream) called packfile, delta-compressed among themselves. Packs are compressed using the heuristic that files with the same name are probably similar, but do not depend on it for correctness. A corresponding index file is created for each packfile, telling the offset of each object in the packfile. Newly created objects (newly added history) are still stored singly, and periodic repacking is required to maintain space efficiency. The process of packing the repository can be very computationally expensive. By allowing objects to exist in the repository in a loose, but quickly generated format, git allows the expensive pack operation to be deferred until later when time does not matter (e.g. the end of the work day). Git does periodic repacking automatically but manual repacking is also possible with the git gc command. For data integrity, both packfile and its index have SHA-1 checksum inside, and also the file name of packfile contains a SHA-1 checksum. To check integrity, run the git fsck command.

Another property of Git is that it snapshots directory trees of files. The earliest systems for tracking versions of source code, SCCS and RCS, worked on individual files and emphasized the space savings to be gained from interleaved deltas (SCCS) or delta encoding (RCS) the (mostly similar) versions. Later revision control systems maintained this notion of a file having an identity across multiple revisions of a project. However, Torvalds rejected this concept.[30] Consequently, Git does not explicitly record file revision relationships at any level below the source code tree.

Implicit revision relationships have some significant consequences:

Git implements several merging strategies; a non-default can be selected at merge time:[36]

Data structures[edit]

Git's primitives are not inherently a source code management (SCM) system. Torvalds explains,[38]

In many ways you can just see git as a filesystem — it is content-addressable, and it has a notion of versioning, but I really really designed it coming at the problem from the viewpoint of a filesystem person (hey, kernels is what I do), and I actually have absolutely zero interest in creating a traditional SCM system.

From this initial design approach, Git has developed the full set of features expected of a traditional SCM,[22] with features mostly being created as needed, then refined and extended over time.

Some data flows and storage levels in the Git revision control system.

Git has two data structures: a mutable index (also called stage or cache) that caches information about the working directory and the next revision to be committed; and an immutable, append-only object database.

The object database contains four types of objects:

The index serves as connection point between the object database and the working tree.

Each object is identified by a SHA-1 hash of its contents. Git computes the hash, and uses this value for the object's name. The object is put into a directory matching the first two characters of its hash. The rest of the hash is used as the file name for that object.

Git stores each revision of a file as a unique blob. The relationships between the blobs can be found through examining the tree and commit objects. Newly added objects are stored in their entirety using zlib compression. This can consume a large amount of disk space quickly, so objects can be combined into packs, which use delta compression to save space, storing blobs as their changes relative to other blobs.

Git servers typically listen on TCP port 9418.[39]


Git is primarily developed on Linux, although it also supports most major operating systems including BSD, Solaris, OS X, and Microsoft Windows.[40]

The JGit implementation of Git is a pure Java software library, designed to be embedded in any Java application. JGit is used in the Gerrit code review tool and in EGit, a Git client for the Eclipse IDE.[41]

The Dulwich implementation of Git is a pure Python software component for Python 2.[42]

The libgit2 implementation of Git is an ANSI C software library with no other dependencies, which can be built on multiple platforms including Microsoft Windows, Linux, Mac OS X, and BSD.[43] It has bindings for many programming languages, including Ruby, Python and Haskell.[44][45][46] It is used as the underlying Git implementation in Microsoft's Team Foundation Service and Visual Studio.[47]

The Plastic SCM versioning system contains its own implementation of the Git protocol, to allow Plastic SCM clients to interoperate with remote Git repositories.[48]

The Perforce version management system also supports Git clients. Perforce can make its versioned content available as Git repositories using the git+ssh protocol, and these repositories can be used as Git remotes from any Git client.[49]

JS-Git is a JavaScript implementation of a subset of Git.[50]


The Eclipse Foundation reported in its annual community survey that as of May 2013, more than 36% of professional software developers use Git as their primary source control system,[5] compared with 27.6% in 2012 and 12.8% in 2011.[51] Open source directory Ohloh reports a similar uptake among open source projects.[52]

The UK IT jobs website reports that as of late November 2013, approximately 15.5% of UK permanent software development job openings list Git as a requirement,[53] compared to 17.1% for Subversion,[54] 11% for Microsoft Team Foundation Server,[55] 1.5% for Visual SourceSafe,[56] and 1.7% for Mercurial.[57]

The following Web sites provide free source code hosting for Git repositories:[58]

Some of these also offer software downloads for self-hosted solutions. Additionally, self-hosted web-based support for hosting Git repositories can also be done with the following software:

See also[edit]


  1. ^ Hamano, Junio (2013-11-20). "[ANNOUNCE] Git v1.8.4.4". git mailing list. Retrieved 2013-12-02.
  2. ^ Hamano, Junio (2013-11-20). "[ANNOUNCE] Git v1.8.5-rc3". git mailing list. Retrieved 2013-12-02.
  3. ^ "git/git.git/tree". Retrieved 2009-06-15. 
  4. ^ Torvalds, Linus (2005-04-07). "Re: Kernel SCM saga..". linux-kernel mailing list. "So I'm writing some scripts to try to track things a whole lot faster."
  5. ^ a b
  6. ^ Feature: No More Free BitKeeper |[dead link]
  7. ^ Torvalds, Linus (2005-04-07). "Re: Kernel SCM saga..". linux-kernel mailing list.
  8. ^ a b c d Linus Torvalds (2007-05-03). Google tech talk: Linus Torvalds on git. Event occurs at 02:30. Retrieved 2007-05-16. 
  9. ^ Torvalds, Linus (2007-06-10). "Re: fatal: serious inflate inconsistency". git mailing list. A brief description of Git's data integrity design goals.
  10. ^ "GitFaq: Why the 'git' name?". Retrieved 2012-07-14. 
  11. ^ "After controversy, Torvalds begins work on 'git'". PC World. 2012-07-14. "Torvalds seemed aware that his decision to drop BitKeeper would also be controversial. When asked why he called the new software, "git", British slang meaning "a rotten person", he said. "I'm an egotistical bastard, so I name all my projects after myself. First Linux, now git"" 
  12. ^ "git(1) Manual Page". Retrieved 2012-07-21. 
  13. ^ a b Torvalds, Linus (2007-02-27). "Re: Trivia: When did git self-host?". git mailing list.
  14. ^ Torvalds, Linus (2005-04-06). "Kernel SCM saga..". linux-kernel mailing list.
  15. ^ Torvalds, Linus (2005-04-17). "First ever real kernel git merge!". git mailing list.
  16. ^ Mackall, Matt (2005-04-29). "Mercurial 0.4b vs git patchbomb benchmark". git mailing list.
  17. ^ Torvalds, Linus (2005-06-17). "Linux 2.6.12". git-commits-head mailing list.
  18. ^ Torvalds, Linus (2005-07-27). "Meet the new maintainer...". git mailing list.
  19. ^ Hamano, Junio C. (2005-12-21). "Announce: Git 1.0.0". git mailing list.
  20. ^ Torvalds, Linus (2006-05-05). "Re: [ANNOUNCE] Git wiki". linux-kernel mailing list. "Some historical background" on git's predecessors
  21. ^ a b Torvalds, Linus (2005-04-08). "Re: Kernel SCM saga". linux-kernel mailing list. Retrieved 2008-02-20.
  22. ^ a b Torvalds, Linus (2006-03-23). "Re: Errors GITtifying GCC and Binutils". git mailing list.
  23. ^ Torvalds, Linus (2006-10-20). "Re: VCS comparison table". git mailing list. A discussion of Git vs. BitKeeper
  24. ^ Torvalds, Linus (2006-10-19). "Re: VCS comparison table". git mailing list.
  25. ^ Dreier, Roland (2006-11-13). "Oh what a relief it is". , observing that "git log" is 100x faster than "svn log" because the latter has to contact a remote server.
  26. ^ "Trust". Git Concepts. Git User's Manual. 2006-10-18. 
  27. ^ Torvalds, Linus. "Re: VCS comparison table". git mailing list. Retrieved 2009-04-10., describing Git's script-oriented design
  28. ^ iabervon (2005-12-22). "Git rocks!". , praising Git's scriptability
  29. ^ "Git User's Manual". 2007-08-05. 
  30. ^ Torvalds, Linus (2005-04-10). "Re: more git updates..". linux-kernel mailing list.
  31. ^ Haible, Bruno (2007-02-11). "how to speed up "git log"?". git mailing list.
  32. ^ Torvalds, Linus (2006-03-01). "Re: impure renames / history tracking". git mailing list.
  33. ^ Hamano, Junio C. (2006-03-24). "Re: Errors GITtifying GCC and Binutils". git mailing list.
  34. ^ Hamano, Junio C. (2006-03-23). "Re: Errors GITtifying GCC and Binutils". git mailing list.
  35. ^ Torvalds, Linus (2006-11-28). "Re: git and bzr". git mailing list., on using git-blame to show code moved between source files
  36. ^ Torvalds, Linus (2007-07-18). "git-merge(1)". 
  37. ^ Torvalds, Linus (2007-07-18). "CrissCrossMerge". 
  38. ^ Torvalds, Linus (2005-04-10). "Re: more git updates...". linux-kernel mailing list.
  39. ^ "1.4 Getting Started - Installing Git". Retrieved 2013-11-01. 
  40. ^ "downloads". Retrieved 14 May 2012. 
  41. ^ "JGit". Retrieved 24 Aug 2012. 
  42. ^ "Dulwich". Retrieved 27 Aug 2012. 
  43. ^ "libgit2". Retrieved 24 Aug 2012. 
  44. ^ "rugged". Retrieved 24 Aug 2012. 
  45. ^ "pygit2". Retrieved 24 Aug 2012. 
  46. ^ "hlibgit2". Retrieved 30 Apr 2013. 
  47. ^ "Microsoft embraces git with new TFS support, Visual Studio integration". Retrieved 1 Feb 2013. 
  48. ^ "Direct push/pull from Plastic SCM to Git". Retrieved 29 Oct 2012. 
  49. ^ "Perforce Aims to Bring Git to the Enterprise". Retrieved 1 Feb 2013. 
  50. ^ "js-git: a JavaScript implementation of Git." Retrieved 13 August 2013.
  51. ^ "Results of Eclipse Community Survey 2012". 
  52. ^ "Ohloh: Compare Repositories". 
  53. ^
  54. ^
  55. ^
  56. ^
  57. ^
  58. ^
  59. ^ Bright, Peter (22 March 2012). "Microsoft brings git support to its CodePlex hosting service". Ars Technica. Retrieved 23 March 2012. 

Further reading[edit]

External links[edit]