The package “gnuit” (GNU Interactive Tools, a file browser/viewer and process viewer) was called “git” in Debian up until 2009-09-09, while git was called “git-core”.

Therefore, a better graph to look at is:

Which shows that the popularity did not rise dramatically (take the green line for the left part until they cross, then take the red line).

The git package in Debian was formerly known as git-core. In April 2010 the package was renamed to git. More details can be found in this blog post by Julius Plenz or this commit in Debian.

Here is a graph that shows the number installs of both git and git-core over time:

I was using Darcs for my own projects for a little while. I switched to git during the rapid ascension that your graph is referring to, so here is my observation:

Distributed source control systems at about that time were a bleeding edge thing. The so-called alpha programmers were using them on the side, but they fell outside of the radar of most professional software developers. The CVS/SVN/SourceSafe/TFS way of looking at the world was one that programmers in general were more or less happy with and most people assumed that the issues that spawned the distributed source control system could be fixed with better tooling. Just as you got an improvement by going from CVS -> SVN that there would someday be something that would allow you to go SVN -> SVN++. How else would you manage source control?

Then came git. What forced git onto everyone’s radar was that there was a huge, public project that immediately adopted it. Git got a lot of users for free–if you were going to do serious kernel hackage, you used git. While I can’t be 100% sure, I would wager that at that point in time no other DVCS had such a large user base.

Then it worked. It worked well. It worked well in public. It also, for its initial warts, was more stable than most concurrent DVCS at the time. Darcs, for example, could be put into an inconsistent state that required an absurdly complex (quadratic? factorial? Can’t recall for sure, but it was bad) utility to fix. Git has always been more stable.

From its large userbase it just sort of bled out.

Every project, commercial or open source, needs that critical mass. Darcs didn’t get it. Neither did Mercurial. Think back. Lots of smaller projects use it. There are probably even a number of commercial users. But what is your big success story?

“If it’s good enough for the Linux kernel, it’s good enough for you” is a very convincing argument.

So, to summarize, it was a good product that came along at the right time and got a large, devoted userbase.

I was a late adopter – switching from Mercurial to Git in around 2010.

The reason I believe Git became so popular is because of sites such as GitHub you had a network effect in version control tools. This was previously not seen, as you would share code on a project or company basis.

I specifically remember switching to Git and Github because all the projects that I was interested in following and contributed to had done the same, as well as developers that I associate with.

That is a network effect.

GitHub was the most popular web based collaboration layer built on DVCS and Git ended up being ‘good enough’. Mercurial was certainly easier to learn and use, Git has many nuances, but had a solid brand because of Linus.

Just because GitHub launched in ’08 and the growth begins in ’10 doesn’t mean GitHub isn’t responsible. If you look at competitive growth charts in other areas such as social networking and the growth of Facebook the line is very similar.

You don’t see growth charts like that without a viral loop / network effect.

For eg. compare to a chart of Facebook growth

Update: I know the source above may not have been accurate, but there are plenty of data sources that demonstrate that Git has been growing exponantially in the past few years.

Graph 1: Mentions of Git in job ads

And the Eclipse survey which shows that Git market share went from 13% in 2011 to 27% in 2012. Amazing growth.

This post makes a much better explanation of Git growth and network effects than what I have done here.

Just to make clear, this graph show the installation of git on debian systems.

Around the time the spike happens the Debian package was renamed from git-core to git. Maybe people found the package easier now that the name reflected the software.

I am surprised no one has mentioned Github as one of the biggest reason for Git to gain popularity. They pushed git mainstream.

Github launched in April 2008 and within 1-2yrs, they gained popularity. And then when you see a sudden explosion of git/git-core usage is primarily due to the 2Million github users and their 3.7million repositories. Github made git easy to use. Bitbucket was there, but github made it effortless. I am sure if github guys picked Hg in place of git, we should have seen a same surge in usage of Hg.

Analogy can be: Canonical:Linux::Github:Git

Well, IMHO, distributed VCS’s like Hg and Git are inherently better than a centralised VCS – so SVN was always going to lose out to one of them.

And git, as has already been observed, had the huge advantage over Hg that it was used by the largest and most successful open-source project on the planet – that’s a hell of a track record, right from the start.

As to why the sudden explosion in early 2010, my guess is fairly prosaic. Git is brilliant, but it’s not massively intuitive for a beginner.

The best Git book, IMHO, is Pro Git, which was published in Sep 2009. The second-best (IMHO again), O’Reilly’s Git book, was published in Jun 2009.

So the reason Git usage exploded in early 2010 could be as simple as the fact that that was when really good resources for learning how to use it became available.

Choosing a version control system is a social decision. The team all needs to use the same solution. As opposed to a text editor, which is a personal decision– different developers can use different editors and easily collaborate.

So there are network effects to choosing a version control system, causing systems that may be a little better or a little more popular to become even more popular.

For example, I prefer darcs for open source projects, but found that more of my potential contributors were familiar with git, and I received more contributions more readily for projects hosted with git instead of darcs. So, I end using git a lot instead darcs. Then, because I use it and publish code on Github, it appears that I endorse it or may even prefer it, which could influence others to use it.

Developers don’t want to learn a new source control system for each project they contribute to, so it benefits the overall community to have a standard that is “good enough” and widely popular, then to have every team and project choose the “best” solution in a vacuum.

Github only added fuel to fire of the network effect.

Looking at the corrected graph in Michael’s answer, showing both git-core and git on Debian systems, the question seems to be why git started to become popular in 2006 on Debian systems and why it grew exponentially between 2006-2012.

The reason could be the strong adoption of Debian-based Linux distributions, like Ubuntu, which started to become popular around 2005-2006 and became the #1 distro up until around 2011, when Mint, also Debian-based, became #1. In the end of 2012, Mint is still #1 and Ubuntu #3 according to DistroWatch.

GitHub, founded in 2008, provided free git hosting, and between 2008 and 2012 became the #1 source repository service in the world with ~2.5 million users and ~4.5 million projects, according to Wikipedia in late 2012.

Rails and many other projects switched from Rubyforge to GitHub in the late 2000s. In addition, Bundler was introduced around the time originally in question (late 2009) with support for installing/updating gems via a :git option in the Gemfile, and Bundler was included as a dependency of Rails 3. Projects in Python, Javascript, C, C++, Java, CSS, etc. also migrated to or started on GitHub.

Those that wanted to contribute to the projects on GitHub needed to fork the project in GitHub, use a local git client to clone the repository before making amendments and pushing them back into GitHub and doing a pull request. This was much simpler than other methods used before and arguably was a significant reason that it was adopted by the projects that moved to GitHub or decided to start there. This meant git-core/git needed to be installed in the Debian-based distros so that developers could use GitHub.

So, I believe that it was a combination of Debian-based distros becoming more popular and growing git adoption because of GitHub’s growth in users and projects, which likely stems from GitHub’s free hosting and user experience.

I think that a lot of people are confusing correlation with causation.

The graphs presented all show correlations between measures of gits popularity and events … and other measures. However, a correlation is not clear evidence for causation.

Some other answers attempt to draw relationships with other things; e.g. Linus Torsvalds evangelism for DVCS, formation of Github, the rise of social networking. While there is evidence of correlation (on a time line) is not as strong, that does not exclude causation. Especially if you accept the “network effect” hypothesis; i.e. that there are multiple causes.

The bottom line, is that the kind of evidence that is available cannot show causation. We are talking about collective behaviour of hundreds of thousands of people, and people make decisions for different reasons … or no logical reason at all. Programmers are no different from anyone else.