In 2005, the development of the Linux kernel faced a crisis that could have slowed down one of the most important free software projects in history. For years, Linus Torvalds and part of the kernel community had been using BitKeeper, a proprietary distributed version control tool that worked well for a huge, decentralized project with thousands of contributions coming from all over the world.
The problem was not technical, but philosophical and operational. BitKeeper was a closed tool, made available under special conditions for open source projects. When that relationship broke down, Torvalds decided he would never again depend on a tool that someone else could take away. His response was to build a new one. In just a few days, Git was born: the version control system that now supports much of modern software development.
Before Git: patches, emails, and a lot of manual work
To understand Git’s importance, it is worth looking back at the state of Linux kernel development in the early 2000s. Linux was no longer a small university project. It had become a central piece of servers, Internet infrastructure, embedded systems, and, years later, Android and much of the cloud ecosystem.
The problem was how to coordinate so many developers. For a long time, changes were sent as patches by email. Maintainers reviewed those contributions, merged them, rejected them, or forwarded them. It was a highly disciplined but very manual system, and it was becoming increasingly difficult to scale.
The existing alternatives did not convince Torvalds. CVS had been the dominant system for years, but it carried significant limitations. Subversion tried to modernize that approach, but it was still centralized. For Torvalds, the Linux kernel needed something different: a distributed system, fast, capable of handling branches and merges without turning every operation into a nightmare.
That is where BitKeeper, developed by BitMover, entered the picture. It was distributed, fast, and better suited to the way the kernel worked. Torvalds adopted it in 2002 despite strong criticism from part of the free software community. Richard Stallman and other free software advocates openly criticized the decision to make Linux dependent on a proprietary tool.
Torvalds defended a pragmatic position: BitKeeper worked and allowed kernel development to move faster. For a while, he was right. Development became more agile, and the tool solved real problems. But depending on a closed solution carried an obvious risk: permission to use it could disappear.
The break with BitKeeper
The relationship collapsed in April 2005. BitMover decided to stop offering the free version of BitKeeper for open source projects after a dispute related to reverse engineering of the protocol. The episode is usually linked to Andrew Tridgell, known for his work on Samba, who investigated how to interact with BitKeeper metadata without using the official client.
For BitMover, that threatened its business model. For the Linux community, the consequence was immediate: the project was left without the tool it had used for three years to manage kernel development.
Torvalds then acknowledged that alternatives had to be explored. In a message reported by LWN, he described life without BitKeeper as a “grey and bleak world.” The phrase captured the moment well: there was no existing option that truly fit the kernel’s needs. But that week of apparent paralysis was not just a pause. It was the beginning of Git.
Ten days to change software development
The first Git commit was made by Linus Torvalds on April 7, 2005. GitHub recalled in 2025, on the project’s 20th anniversary, that Torvalds wrote Git in about 10 days after losing access to BitKeeper. That first commit already contained enough code for Git to start managing its own source code.
The speed at which Git was born should not be confused with improvisation. Torvalds knew exactly what he wanted to build. Git had to be distributed, extremely fast, and reliable. Every developer needed to have a full copy of the repository. There could not be a central server whose failure, lockout, or withdrawal would paralyze the project. The BitKeeper experience became a design principle: no one should be able to revoke a community’s access to its own work history.
Integrity was also essential. Git uses cryptographic hashes to identify objects and commits, so altering history leaves evidence. Trust is not based only on permissions or contracts, but on the structure of the data itself.
| Date | Milestone |
|---|---|
| 1991 | Linus Torvalds starts the Linux project |
| 2002 | Linux kernel development adopts BitKeeper |
| April 2005 | BitMover withdraws the free BitKeeper license for open source projects |
| April 7, 2005 | Torvalds makes the first Git commit |
| 2005 | Junio C Hamano takes over as Git’s main maintainer |
| 2008 | GitHub launches, built on Git |
| 2016 | BitKeeper is released as open source under the Apache 2.0 license |
| 2018 | Microsoft acquires GitHub for $7.5 billion |
After creating the initial foundation, Torvalds handed Git’s maintenance to Junio C Hamano, who became a key figure in turning a tool born out of crisis into a solid, stable, and widely adopted project.
GitHub turned Git into a culture
Git was already important for the Linux kernel, but its impact multiplied with the arrival of GitHub in 2008. The platform did not invent Git, but it did something just as decisive: it turned distributed version control into a social and collaborative experience.
Branches, forks, pull requests, public code review, issues, and developer profiles helped create a new culture of collaboration. Git stopped being just a low-level tool and became the center of daily work for millions of programmers.
In 2018, Microsoft announced the acquisition of GitHub for $7.5 billion in stock. The deal symbolized just how much Git had become critical infrastructure for the software industry. A company that had long been viewed with suspicion by parts of the open source community was buying the largest code collaboration platform built on a tool born in the Linux world.
In January 2023, GitHub announced it had surpassed 100 million developers on its platform. That number does not represent all Git users worldwide, since Git is also used on GitLab, Bitbucket, private environments, companies, universities, and self-hosted servers. But it does show the scale of the tool’s impact: Git has become the common language of modern software development.
BitKeeper arrived too late to open source
The historical irony is clear. BitKeeper, the tool whose withdrawal pushed Torvalds to create Git, was eventually released as open source in 2016 under the Apache 2.0 license. By then, Git had already conquered the industry. BitKeeper arrived late to openness and never regained comparable relevance.
Its role in history, however, was important. BitKeeper showed that distributed version control was the right path for large, decentralized projects. It also taught a harder lesson: if an open community depends on a closed tool, its continuity is conditioned by external decisions.
Git was born precisely to remove that dependency. It was not just a technical tool; it was an architectural response to a trust problem. That is why its success cannot be explained only by speed or efficiency. It succeeded because it matched the philosophy of open development: every developer keeps a full copy, every history can be verified, and no single provider controls the entire workflow.
The most productive revenge in technology
Calling Git “revenge” may sound exaggerated, but it helps explain the spirit of the story. Torvalds did not respond to BitKeeper with a legal battle or a public campaign. He responded by programming. He built a tool that made the dependency that caused the crisis unnecessary.
Twenty years later, Git is an invisible but essential piece of software infrastructure. It sits behind open source projects, enterprise software, DevOps deployments, continuous integration, AI platforms, mobile apps, cloud systems, and private repositories of every kind. It is used by students, startups, big tech companies, and public administrations.
The story of Git shows something that goes beyond programming: a technical crisis can become an opportunity when it forces a system to be rethought from the ground up. BitKeeper solved a real problem, but it did so under fragile conditions. Git solved the same problem with a different premise: control had to be distributed.
In 2005, Linus Torvalds needed a tool to keep developing Linux. He ended up creating one of the fundamental infrastructures of modern software.
Frequently asked questions
Why did Linus Torvalds create Git?
Linus Torvalds created Git in 2005 after BitMover withdrew the free BitKeeper license for open source projects. The Linux kernel needed a distributed, fast, and reliable tool to manage thousands of contributions.
Was Git really created in 10 days?
GitHub and several historical sources recall that Torvalds wrote the first functional version of Git in about 10 days. The first commit was made on April 7, 2005, and the project quickly began being used in Linux kernel development.
How is Git different from CVS or Subversion?
The main difference is that Git is distributed. Every developer has a full copy of the repository, including its history. CVS and Subversion were based on a centralized model, which was less suitable for a global project like the Linux kernel.
What role did GitHub play in Git’s success?
GitHub, launched in 2008, made Git much more accessible and social. It popularized workflows such as pull requests, forks, public code review, and professional identity based on open source contributions.