Google Developers Blog

Accelerating development for massive Git repositories

8.5内容质量

TL;DR · AI 摘要

ABFS通过内容寻址技术将Android项目代码同步时间从36分钟缩短至8秒,构建时间从80分钟降至2分钟。

核心要点

  • ABFS使Android代码检查时间从36分钟缩短至8秒
  • 构建时间从80分钟减少到2分钟
  • 支持跨工作区并行处理和100%缓存复用

结构提纲

按章节快速跳转。

  1. 揭示Android项目因代码量庞大导致的开发效率瓶颈问题

  2. §ABFS架构

    介绍包含Linux内核模块、用户空间守护进程和服务器端的完整技术栈

  3. 展示检查时间和构建时间的量化改进数据

  4. 解析内容寻址技术如何实现构建结果复用

  5. 分析Android 17项目规模及ABFS优化效果

思维导图

用一张图看清主题之间的关系。

查看大纲文本(无障碍 / 无 JS 友好)
  • ABFS技术架构
    • 核心特性
      • 内容寻址技术
      • 懒加载与缓存
      • 并行处理支持
    • 性能指标
      • 检查时间8秒
      • 构建时间2分钟
      • 100%缓存复用
    • 应用场景
      • Android开发
      • 大规模Git项目

金句 / Highlights

值得收藏与分享的关键句。

#Git#构建工具#Android#ABFS#开源
打开原文

Accelerating development for massive Git repositories - Google Developers Blog

Google Tag Manager (noscript)

End Google Tag Manager (noscript)

HTML

Accelerating development for massive Git repositories

NOV. 17, 2026

The Android ABFS Team

Share

  • Facebook
  • Twitter
  • LinkedIn
  • Mail

Android’s source code is big – the Android 17 open source release has 1,084 Git repositories, 1.62 million files, and takes 300 GB for a built workspace. Additionally, in a typical Android source tree with hardware vendor code and first-party applications, the size increases by 2-3x . Traditionally, it took over 30 minutes to fetch Android Open Source Project (AOSP) source code and well over an hour to build on even highly capable developer workstations. As software development evolved over the last 2 years, modern coding harnesses and LLMs have accelerated the development of many projects. These tools are used today for Android operating system development, but the long sync and build times make them less efficient. Both human developers and agents need quick setup, parallel workspaces, and fast build-and-test iteration times.

We built Another Build File Service (ABFS) to address these bottlenecks. ABFS is a full suite of software across a Linux kernel filesystem module, user-space daemons, and server-side infrastructure. ABFS uses content-addressability across the entire stack to lazy-load and cache source code, developer workspaces, intermediate build files, and build results.

Today, we are excited to announce that ABFS is open source on GitHub . The impact of ABFS to Android is:

  • Reduced checkout times from ~36 minutes to under 8 seconds .
  • Reduced full build times from ~80 minutes to just over 2 minutes .
  • Enabled parallel agentic workflows across multiple workspaces and agent orchestrators.
  • Shared cache reuses up to 100% of build actions across continuous integration (CI) and developer workspaces.

ABFS already powers parallel workflows for developers and agents in Android, but it is designed to scale to other massive Git-based projects.

Case Study: Android

In the Android build system, developers define build rules in Blueprint files ( Android.bp ), Soong compiles them into Ninja files, and Ninja executes the final build graph (see the Android build overview ). Similar to the Make build tool , Ninja is timestamp-based . If a build step’s input file is newer than the existing output file, Ninja rebuilds the output file.

Code Size

Analyzing the AOSP code for Android 17 shows the sheer disk footprint and file count involved in a single checkout and build.

Table of Android Open Source Project (AOSP) scale for Android 17: 1,084 Git projects, 1,620,371 regular files, 324,457 directories, 161 GB total code size, and 155 GB build output.

In a typical Android tree that includes hardware-specific repositories, board support packages, first-party applications, form-factor-specific code, etc., the code size is 2–3 times the size of AOSP (over 3,000 Git repositories), compounded across multiple active SKU and legacy maintenance branches.

Build Cacheability

Building the Cuttlefish emulator target executes a build graph with 192,249 Ninja actions. While local incremental builds are fast once a tree is already built, every new workspace, branch switch, or ephemeral agent session starts cold. Even though typical developer changes touch only 1-10 different Git projects, someone building locally without any remote execution might waste up to 80 minutes on a 64-core machine repeating work their CI system already built. Even if a developer edits a core library like system/libbase , 97% of the build graph is identical to the CI build.

Unspecified Dependencies

Sharing cached build outputs across CI and local machines is also tricky in a codebase of Android's age and rate of change. Build rules occasionally introduce hidden dependencies (such as passing an undeclared schema file inside raw compiler flags), over-declared inputs , or undeclared outputs . In timestamp-based builds, hidden dependencies silently produce stale incremental artifacts, forcing developers to wipe output directories and run clean builds.

Solution: ABFS

ABFS makes building Android fast by replacing massive local source checkouts with a virtual, content-addressable filesystem (CASFS). ABFS streams files on demand only when a build actually touches them and utilizes shared build caching to help eliminate redundant downloads and compilation.

Architecture diagram showing client-side components (Ninja-go, Tap, Mount Daemon, Cacheman, Local Cache, and the CASFS Kernel Module) and server-side components (ABFS CAS Server and Git-pushers connected to a Git source of truth).

On the server side, Git-pushers continuously ingest new Git objects from Gerrit or other Git hosts into a horizontally scalable gRPC ABFS Content-Addressable Storage (CAS) Server that indexes Git content, workspace snapshots, and build step results. On the developer host, a local Least Recently Used (LRU) Cacheman daemon, Mount Daemon , and Tap utility connect user-space build tools to the kernel filesystem so checkouts and builds stream only what they need. See the full ABFS architecture on GitHub .

Filesystem

At the core of the client is a virtual filesystem called Content-Addressable Storage Filesystem (CASFS) , a Linux kernel module that exposes Git SHA content hashes via extended attributes. When a file's hash is set, CASFS populates its metadata immediately and downloads file bytes via Cacheman only when needed:

code
$ 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

Shell

Copied

Initial checkouts download only lightweight directory metadata prepopulated with Git hashes. CASFS uses Git's object model natively, allowing standard git and repo operations to work transparently.

Correct two-phase build caching

CASFS can also tap build processes. Tapping records every file actually read, written, or deleted into lists called patches , which are stored alongside cached build outputs. Ninja-go replaces timestamp checks with two-phase content-addressable caching:

  • Phase 1 - Declared key lookup: Ninja-go hashes a step’s command, environment, and declared input hashes to fetch candidate results from prior CI or developer builds.
  • Phase 2 - Read-patch verification: Before accepting and applying a candidate result, ABFS verifies the candidate’s recorded read patch against the current CASFS state. In the common case, this read patch will match the filesystem state and then the write patch is applied. If even a hidden dependency has a different hash on disk, ABFS rejects the stale candidate and reruns the step with tapping enabled. This preserves clean-build correctness even when the build graph is incomplete.

Ninja-go accelerates Ninja-based builds like Android and Chrome; other build systems can integrate with ABFS's caching APIs using the same model (see the two-phase caching walkthrough on GitHub ).

Synchronized workspaces

Each mounted checkout attaches to a persistent workspace that eagerly syncs modified files, git state, and repo state through Cacheman to the ABFS CAS Server—keeping mounts synchronized across sessions or across multiple developer hosts.

Sorry, your browser doesn't support playback for this video

Results

The benchmarks below show the mean time of 3 Android runs on a GCE n2d-standard-64 VM with 64 vCPUs and 256 GB of RAM. The ABFS remote server was running in the same cloud network as the client.

Source checkout

Note: The “Current” flow used repo init --partial-clone and repo sync -j8 as documented in official Android documentation (higher -j values hit Gerrit rate-limiting on android.googlesource.com).

Build

Note: All of these builds used lunch aosp_cf_x86_64_only_phone-aosp_current-userdebug and m droid to build.

Checkout and build demo

Link to Youtube Video (visible only when JS is disabled)

Unlocking agent development

Because ABFS does lazy loading and local cache deduplication, developers and their agents can now mount multiple concurrent Android workspaces on a single machine, benefit from a shared local build cache, and achieve massive scale in development time.

code
# 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

An agent can check out a full Android tree in under 10 seconds and perform a full build in under 10 minutes . Agent swarms are empowered to iterate, review, and test in parallel, which can lead to higher quality solutions and speed. In the demo below, an agent makes a system/libbase fix on the latest AOSP release, then 4 parallel agents simultaneously backport, build, and test the fix across 4 more AOSP releases on a single VM.

Agent development demo

Note: AOSP releases before Android 17 require some patching to work with ABFS.

Extending beyond Google and Android

We released ABFS as open source because we want developers, Android partners, and any large-scale Git-based project to benefit from what we have learned and be able to scale.

While Android’s Soong/Ninja pipeline was the first acceleration target, ABFS was built to be extensible to other build systems. Content-addressable build systems like Bazel map naturally onto CASFS and there is already a proof-of-concept integration with Bazel . Chromium, the Android Common Kernel, and other Google projects are exploring ABFS compatibility.

Explore ABFS , CASFS , and Ninja-go on GitHub, and reach out to us at [email protected].

For help with the Google Cloud server-side, infrastructure-as-code, and CASFS for Cloud Workstations and Kubernetes, please reach out to [email protected].

Acknowledgements

We’d like to extend a special thanks to our significant contributors for their work on this project:

Haamed Gheibi, Erik Sanders, Rob Seymour, Taylor Santiago, Andrew Hsieh, Eric Taseski, Kiyoung Kim, Hung-Wei Chen, Jose “Pepe” Galmes, Ronald Li, Yu-Che Wang, Roger Ellis, Sandeep Patil, Amith Dsouza and the entire Android Build team

posted in:

  • Mobile
  • AI
  • Cloud
  • Case Studies
  • Announcements
  • Solve

Previous

Next

Related Posts

List

Web

AI

Announcements

Solutions

Build full-stack Android apps with Gemini in Google AI Studio

Cloud

Tutorials

Case Studies

Unlocking Stable On-Policy RL on TPU with Bitwise-Zero Train–Inference Mismatch

NOV. 16, 2026

Gemini 4 Hydrogen: a faster model for general purpose robotics

Navigation dots