Google Accelerates Massive Git Workflows for Android
On , Google open-sourced Another Build File Service (ABFS), an enterprise system built to end the source synchronisation delays that come with massive Git repositories. The release arrives with Android 17, whose open source tree spans 1,084 repositories, 1,620,371 regular files, and 161 GB of source. Add vendor board support packages and proprietary device apps, and the total passes 3,000 repositories.

The before and after figures are the headline. Syncing an Android tree used to take 36 minutes, and a full build ran roughly 80 minutes on a 64-core Google Compute Engine instance with 256 GB of memory. With ABFS, checkout drops to under 8 seconds and a full build to just over 2 minutes, with up to 100 percent build action reuse between CI pipelines and local developer workstations.

Source Files Arrive Only When Something Reads Them

The speedup starts with the Content-Addressable Storage Filesystem (CASFS), a Linux kernel module that exposes Git object hashes through extended attributes. Instead of downloading gigabytes of code nobody has opened, CASFS fills a new workspace with file names and directory trees as thin metadata stubs. A local Cacheman daemon then streams the real file contents over gRPC from server-side storage, but only when a compiler or developer process opens the file.

$ touch hello
$ abfs hash --set cc628ccd10742baea8241c5924df992b5c019f71 hello   # metadata only
$ ls -l hello   # name and size are available; content is not downloaded yet
-rw-r----- 1 user primarygroup 6 Nov 3 00:11 hello
$ cat hello   # content is lazy-loaded on first read
world

Work is split between client and server so the design holds up across large engineering teams:

  • The ABFS CAS Server indexes remote snapshots, build results, and commits straight from upstream review hosts.
  • A local Least Recently Used (LRU) Cacheman daemon manages storage caches and deduplicates payloads across sessions.
  • The Mount Daemon links the virtual directory structures into standard operating system tooling without any special handling.

Two Phases of Caching Catch Undeclared Dependencies

Fast checkout only helps if builds can reuse earlier work safely. Build tools like Make and Ninja lean on timestamps, which break down when an engineer introduces a hidden dependency, such as an input that affects a compiler flag but is never declared. The scale is large: in the standard Android build, building the Cuttlefish emulator triggers 192,249 actions, and even a small change to a core library like system/libbase shares 97 percent of its dependency graph with CI.

To reuse cached artifacts without serving stale results, ABFS pairs with Ninja-go and runs two-phase caching:

  • Phase 1 hashes the command line, execution environment, and declared inputs to find candidate results.
  • Phase 2 checks each candidate against the filesystem reads recorded by the kernel tap module. If an undeclared input has changed on disk, ABFS rejects the candidate and runs the compilation step from scratch.

The same design suits autonomous software agents. In testing, an agent can mount five Android release branches side by side in under eight seconds each, which lets four parallel agents backport, build, and test a single patch across older trees at the same time.

# Mount 5 distinct Android release branches side-by-side in under 8 seconds each
$ abfs mount -b android-latest-release /ws/a17
$ abfs mount -b android16-qpr2-release /ws/a16qpr2
$ abfs mount -b android16-release /ws/a16
$ abfs mount -b android15-release /ws/a15
$ abfs mount -b android14-release /ws/a14

Hashlytics Take

Both headline gains come from skipping work, not doing it faster. Checkout is quick because nothing is downloaded until it is read, and builds are quick because most actions are reused from CI. That makes the 97 percent overlap figure the number to watch, since a team whose local changes diverge widely from its CI pipelines will not see anything close to a two-minute build. ABFS is now open source on GitHub, so the real test is whether third-party enterprises with large monorepos can reach Google’s two-minute threshold on their own cache hit rates.

Follow Hashlytics on Bluesky, Facebook, LinkedIn , Telegram and X to Get Instant Updates