Unity 6.6 LTS Addressables Catalog Loads Old Bundle Hash - Remote Path and Cache Invalidation Fix - How to Fix

Problem: Your Unity 6.6 LTS build publishes successfully, but clients still fetch an older Addressables bundle hash. The catalog appears updated in CI output, yet runtime behavior matches stale content.

Common symptoms:

new gameplay values are missing after patch deployment
catalog file timestamp changes, but bundle content remains old
one tester sees updated assets while another sees previous bundle data
cold install behaves differently than an already-installed device

This is usually a remote path and cache invalidation sequencing issue, not a random Unity runtime failure.

Why this spikes now (Unity 6.6 LTS migration lanes in 2026)

In 2026, Unity 6.6 LTS migrations are being merged alongside live content updates. Teams are changing profile paths, CDN routing, and release cadence in the same sprint. That mix creates a common failure mode where the catalog updates but the effective bundle fetch still resolves through stale cache layers.

When migration work and patch publishing happen together, stale-hash incidents rise because:

remote load paths move between environments
CDN invalidation timing differs by edge region
release teams validate editor output but skip client-side cache-state checks

Root cause

Most stale-hash incidents come from one or more of these:

Profile remote path drift
Build-time and runtime paths do not resolve to the same catalog or bundle origin.
Catalog update without bundle cache invalidation order
Catalog points to new hash, but client still serves old cached bundle artifact.
Mixed release artifacts in same lane
CI publishes catalog from candidate N and bundles from candidate N-1.
CDN edge propagation lag
Origin is updated, but one or more regions still serve previous hash.
No deterministic client verification route
Team checks logs but does not run repeatable fresh-install and warm-cache validation.

Quick fix checklist

Lock one release tuple (branch, build id, catalog revision, expected bundle hash).
Verify runtime remote load path resolves to the same lane as build output.
Enforce catalog publish followed by bundle availability and cache invalidation sequence.
Validate with both fresh-cache and warm-cache clients.
Record one release readback row before promotion.

Step 1 - Lock a single Addressables release tuple

Before touching settings, define:

release_branch
catalog_revision_id
expected_bundle_hash
remote_load_path
cdn_distribution_id (or equivalent)

If people validate different tuples, stale-hash triage becomes noise.

Step 2 - Verify profile and runtime remote path alignment

Check your Addressables profile and runtime config:

confirm build script outputs catalog and bundles to expected origin path
confirm runtime load path targets the same environment lane
confirm no fallback profile points to stale path from previous lane
check platform-specific path overrides (Android/iOS) for drift

If runtime points to an older path alias, hash checks will fail even when CI is green.

Step 3 - Enforce publish order

Use this safe order:

upload new bundles
verify bundle availability at origin
publish new catalog referencing those bundle hashes
invalidate CDN cache keys for catalog and impacted bundles
wait for propagation window

Publishing catalog before bundle availability can force clients into stale fallback behavior.

Step 4 - Validate cache behavior on two client states

Run both:

fresh-state test (clean install or cleared app cache)
warm-state test (existing install with prior catalog data)

For each, verify:

fetched catalog revision
resolved bundle hash
in-game version marker tied to the patch

If only fresh-state passes, your warm-cache invalidation flow is incomplete.

Step 5 - Add release readback gate before promotion

Record one final gate row:

branch
catalog revision id
expected bundle hash
runtime load path
verification account/device
timestamp

Treat this row as required for every patch lane promotion.

Verification checklist

After the fix, confirm:

fresh-state and warm-state clients resolve the same bundle hash
runtime load path matches release tuple
catalog and bundle artifacts come from the same candidate
CDN edge region checks return updated content
gameplay or data marker for the patch is visible on both client states

Alternative fixes for stubborn edge cases

If stale behavior persists:

create versioned release directories per candidate to avoid alias collisions
temporarily reduce cache TTL for catalog endpoints during migration windows
add startup diagnostics that print catalog revision and resolved bundle hash
isolate one region for canary validation before global promotion

Prevention tips for future Unity 6.6 patch lanes

freeze Addressables profile path changes during release week
separate migration changes from live content promotions where possible
require tuple readback in release approvals
run one deterministic two-state cache smoke test per promoted candidate