GitHub’s Rubicon storage architecture targets 7,200 pushes per second per repo
GitHub details Project Rubicon, its new Git storage architecture, tested at 5,000 concurrent agents and 7,200 pushes per second to a single repository.
GitHub has detailed “Project Rubicon,” a new Git storage architecture it says can handle thousands of writes per second to a single repository while reads scale on demand. In internal testing, the company says it demonstrated support for 5,000 concurrent agents working on one repository and 7,200 pushes per second to it, while serving read traffic with consistently low latency.
GitHub first announced the architecture at its Universe conference the week before the post, published November 5 by engineers Karthik Raman and Brian Celenza. The company says the design is already running underneath GitHub, which kept operating while it was built.
Only reference updates need agreement
The design rests on an observation GitHub made in earlier posts in the series: Git objects are immutable and named by their contents, so two writers can store them at the same time without coordinating. Only the reference update — the small part of a push that says where a branch now points — needs agreement.
That lets storage, request serving and repository maintenance scale independently. For developers, GitHub says, Git stays Git: pushes, fetches and branches work the same way, with the same protections.
Durable state now lives in two places. Git objects, as packs plus read-acceleration data, sit in Azure Blob Storage. References and the pack manifest live in a separate replicated log service GitHub calls Ref-CAS, for “Reference Compare-and-Swap.”
On a write, a virtual replica indexes the incoming pack and uploads it to Blob Storage, then commits one transaction to Ref-CAS listing the pack and updating the references. On a read, a replica checks its reference version with Ref-CAS, pulls the needed packs into its cache and serves from there. If nothing has changed, the version check returns no references at all.
Why object storage wasn’t enough for references
GitHub tried two Blob Storage approaches for reference state before building Ref-CAS. A single write-ahead log blob, updated by conditional writes, was correct and cheap to read but capped writes at one per round trip — in practice, “write throughput in the mid-hundreds per second.” Splitting references across several segment blobs raised the write ceiling but forced every read to check all segments, trading write latency for read latency.
Ref-CAS instead commits each reference update as a compare-and-swap through a quorum, locking only the references it touches. Each commit gets a log sequence number, and the repository’s version is the latest one. GitHub says this lets it transact reference state alone “in the tens of thousands of operations per second.” Ref-CAS never holds or validates object data, only pointers to it.
Compaction, which merges packs so lookups stay cheap, now runs in the background on separate nodes rather than on the replicas serving traffic. Compaction nodes claim subsets of a repository’s data via leases.
GitHub frames the work as preparation for agent-driven development: the busiest repositories today see at most dozens of writes per second in short bursts, but the company expects those bursts to become sustained within the next year. It set a target of at least two orders of magnitude more scale rather than planning for the next increment.
The full engineering post, including the request flow and component details, is on the GitHub Blog. GitHub has not announced any change to how developers push, fetch or branch.
Related reading
Sources
- Inside GitHub’s new Git storage architecture — GitHub Blog
Some links on this page may be affiliate links. If you buy through them we may earn a commission at no extra cost to you. See our affiliate disclosure.