The Birth of Git
From Crisis to Revolution
In the early 2000s, the Linux kernel project needed a robust version control system. After outgrowing tools like CVS and the patch-and-email workflow, the kernel community turned to BitKeeper, a proprietary distributed version control system. BitKeeper was chosen for its impressive performance and ability to manage large-scale, distributed development—critical for a project as vast and collaborative as the Linux kernel.
However, in April 2005, everything changed. BitMover, the company behind BitKeeper, revoked free access to the Linux development community. The trigger for this decision was a dispute over reverse engineering: a developer connected to the Linux project was accused of attempting to reverse-engineer BitKeeper’s proprietary protocols in an effort to create an open-source client. This violated the agreement between BitMover and the kernel community. In response, BitMover pulled the plug on free access, citing concerns over trust and licensing violations. The Linux community, which had deeply integrated BitKeeper into its workflow, was suddenly without a reliable version control system.
Faced with this unexpected challenge, Linus Torvalds, the creator of Linux, was determined to find a solution. He needed a distributed version control system that could handle the scale of Linux kernel development. However, the available free systems didn’t meet his performance standards. Torvalds famously pointed out that existing systems required up to 30 seconds to apply a patch and update associated metadata—something that would not scale to the kernel’s needs. With 250 developers working on the kernel simultaneously, syncing patches in 30-second intervals would be far too slow. His goal was clear: patching should take no longer than three seconds.
Rather than relying on existing tools, Torvalds made the bold decision to build his own version control system. In just 10 days, he developed the foundation of what would become Git—a distributed, high-performance, and secure VCS designed from the ground up to handle collaborative development at scale.
Git’s development began on April 3, 2005. Linus announced the project on April 6, and by the next day, Git was already self-hosting. On April 18, Git’s first successful merge of multiple branches took place. By April 29, the system had met its performance goals, processing patches at an astonishing rate of 6.7 patches per second. On June 16, Git successfully managed the Linux kernel 2.6.12 release.
While the early version of Git was raw and script-based, its architecture set the stage for something transformative. Within weeks of its official release in mid-April 2005, Git was already in use by kernel developers, replacing BitKeeper with a system that was faster, more flexible, and better suited to the needs of large-scale software projects.
From Necessity to Universality
Git didn’t just replace BitKeeper—it quickly outgrew it. Over the next few years, it evolved into a powerful, general-purpose version control system:
2005–2008: Git rapidly matured with contributions from the open-source community, new features, and improved usability.
2008: The launch of GitHub made it easier than ever to collaborate, share code, and build communities around projects.
2010s: Git became the de facto standard for version control, both in open-source and enterprise software development.
Today: Git powers projects of all sizes, from personal side projects to massive codebases at companies like Google, Microsoft, Meta, and countless others.
What started as a crisis turned into one of the most influential innovations in software development. Git didn’t just solve the immediate problem—it changed how developers work together and how software is built worldwide.
To celebrate two decades of Git, GitHub interviewed Linus himself to revisit the early days, explore the key design decisions behind Git’s lasting success, and discuss how it has forever changed software development.
Transcript: Git turns 20: A Q&A with Linus Torvalds - The GitHub Blog