Google Android Source Git Tags Missing: Fixes for Developers

Developers pulling from the Android Open Source Project have hit a wall: Google has stopped publishing Git tags for portions of the Android source tree, breaking build reproducibility, version pinning, and downstream tooling that relies on tagged references. This is a widely reported issue affecting custom ROM maintainers, security researchers, kernel developers, and anyone building against AOSP on macOS workstations. If you rely on Apple hardware to sync and compile Android sources, the disruption is real and the workarounds are not always obvious.

This guide walks through the root cause, immediate fixes you can apply from your Mac, and longer-term strategies to keep your build pipeline stable while Google’s tagging behavior remains inconsistent.

What Causes This Issue

The Android source is distributed across hundreds of Git repositories orchestrated by the repo tool. Historically, each platform release carried matching Git tags across every project — for example, android-14.0.0_r1 — allowing anyone to check out a precise, reproducible snapshot. Starting earlier in 2026, several of these repositories stopped receiving new tags, even though code drops continued through manifest updates.

Users in the Apple Support Community and broader developer discussions have flagged several contributing factors:

• Internal workflow changes at Google: The company appears to have shifted some components to a manifest-only release model, where the canonical version reference lives in the default.xml manifest rather than in per-repository tags.
• Selective publishing: Certain subsystems — particularly newer Pixel-specific components, some kernel branches, and prebuilt binaries — never receive public tags at all.
• Tag propagation delays: Even where tags do appear, they can lag manifest updates by days or weeks, causing scripts that watch for tags to miss releases entirely.
• macOS-specific sync issues: On Apple Silicon Macs, case-sensitivity defaults on APFS and repo’s handling of partial fetches can compound the problem by silently skipping projects that lack expected refs.

The upshot: if your build system checks out sources by tag, some projects will simply not resolve, and repo sync will either warn quietly or fall back to HEAD — neither of which gives you a reproducible build.

Step-by-Step Fixes

Because there is no accepted single solution posted in the community thread, the most reliable approach is to switch your pinning strategy from tags to manifest commit hashes. Work through these steps in order:

1. Verify your repo tool version. Open Terminal on your Mac and run repo –version. If you’re below 2.45, upgrade with brew install repo or pull the latest launcher from the official source. Older repo binaries handle missing refs poorly.
2. Switch initialization to a manifest revision, not a tag. Instead of repo init -b android-14.0.0_r1, target the manifest commit directly: repo init -u https://android.googlesource.com/platform/manifest -b main -m <snapshot>.xml. Snapshot manifests pin every project by SHA, sidestepping the missing-tag problem entirely.
3. Generate your own local snapshot manifest. After a successful sync, run repo manifest -r -o pinned.xml. This writes a manifest with explicit revisions for every project. Commit this file to your own Git repository so future builds are reproducible regardless of Google’s tagging behavior.
4. Run repo sync with strict flags. Use repo sync -c -j8 –fail-fast –force-sync. The –fail-fast flag stops the sync immediately if any project fails to resolve, so you don’t discover missing sources hours into a build.
5. Audit projects for missing tags. Run a quick shell loop: repo forall -c ‘git tag –list | grep android-14 || echo MISSING: $REPO_PROJECT’. This produces a list of repositories that lack the expected tag so you can decide whether to pin them by branch, commit, or accept HEAD.
6. Rebuild your ccache and out directories. If prior syncs left partial state, delete out/ and clear ~/.ccache before rebuilding. Stale artifacts referencing missing tags will cause opaque build failures.

Additional Solutions

Beyond the immediate fixes, several longer-term strategies help insulate your workflow from Google’s inconsistent tagging:

• Mirror upstream to your own Git server. Tools like Gerrit, self-hosted GitLab, or a simple bare-repo mirror on a Mac mini let you snapshot AOSP on your schedule. Once mirrored, you control tagging conventions and never lose access to a specific revision.
• Use case-sensitive APFS volumes for AOSP builds. On macOS, create a dedicated case-sensitive APFS volume in Disk Utility for your source tree. AOSP contains files whose names differ only by case, and the default case-insensitive APFS will silently collide them, masking sync problems as tag problems.
• Pin the manifest repository itself. The platform/manifest repo does still receive tags reliably. Pinning to a manifest tag gives you a reproducible starting point even when downstream project tags are absent.
• Subscribe to the AOSP announcement list. Google occasionally posts advisories about tagging changes and manifest updates. Watching these announcements lets you adapt scripts before they break silently.
• Use Docker or Lima on Apple Silicon. Running your AOSP build inside a Linux container via Lima or OrbStack eliminates a class of macOS-specific filesystem quirks and gives you a build environment closer to what Google tests against.
• Cache prebuilt kernels separately. Kernel prebuilts are among the most frequently untagged components. Fetch them by explicit SHA from android.googlesource.com and store them alongside your pinned manifest.

When to Contact Apple Support

This issue originates upstream at Google, not with Apple, so Apple Support cannot restore missing Git tags or alter repo tool behavior. However, contact Apple Support if you experience macOS-side symptoms that could compound the problem:

• APFS volume corruption during large repo sync operations, especially on external SSDs.
• Persistent Terminal or Xcode Command Line Tools failures after a macOS update, including missing git, python3, or curl binaries.
• Rosetta 2 crashes when running x86_64 build tooling on Apple Silicon.
• iCloud Drive interfering with source directories — move AOSP checkouts outside any synced folder before contacting support.

For tag-related and repo-related issues, the appropriate channels are the AOSP issue tracker and the public Android developer forums. Apple Support can only help with the underlying platform.

FAQ

Are all Android repositories missing tags, or only some? Only some. Core platform repositories like frameworks/base generally continue to receive tags, while newer components, Pixel-specific projects, and certain kernel branches are affected inconsistently.

Will this break my existing builds? Only if your scripts check out by tag and fail hard when a tag is missing. Builds that use manifest-based pinning are unaffected.

Can I file a bug with Google? Yes. The AOSP issue tracker accepts reports about missing tags. Include the project path, the expected tag, and the manifest revision you were building against.

Does this affect LineageOS or other custom ROMs? Indirectly. ROM maintainers typically maintain their own manifests and tagging conventions, but they still consume upstream sources, so untagged AOSP components can delay their releases.

Is there a way to detect missing tags automatically? Yes — a scheduled script running git ls-remote –tags against each project in your manifest can alert you when expected tags fail to appear within a set window after a platform release.

Should I stop using repo entirely? No. Repo remains the correct tool for AOSP. The fix is to change how you pin revisions, not to abandon the tooling.