2026 Exklusiver Fern-Mac iOS/macOS CI: Xcode 26 Compilation Cache vs. sccache/ccache Remote-Kompilierungs-Caches — Explizite Module, SPM-Blindspots, parallele Job-Verzeichnis-Isolation und SSH-headless reproduzierbare Entscheidungsmatrix + FAQ

1. Drei Cache-Ebenen kartieren — nicht einen Schlüssel für jede Art von „schnell“

Ebene A — Xcode 26 Compilation Cache (in Apples Toolchain): Wiederverwendung von Compilation Units unter derselben Toolchain-Version, eng gekoppelt an explizite Module und einen stabilen Modulgraphen. Optimiert „gleiche Maschine, gleiches SDK, gleiche TU erneut“ — nicht automatisches Teilen über Xcode-Punktreleases oder verschiedene DEVELOPER_DIR-Wurzeln.

Ebene B — DerivedData / Modul-Cache-Verzeichnisse: Projektindizes, vorkompilierte Module, Swift-Inkrementalzustand. Für einen dedizierten Runner geeignet, aber bei parallelen Jobs ist Verzeichnis-Isolation Pflicht — sonst schreibt Job A, während Job B einen halbfertigen Index liest.

Ebene C — sccache / ccache (Compiler-Wrapper + Remote-Object-Storage): Fängt clang / swiftc ab und mappt Hashes vorverarbeiteter Compile-Befehle auf gemeinsamen Speicher (S3, MinIO, NAS). Stark für Runner- und Branch-übergreifende Wiederverwendung; teuer, wenn Schlüssel Sandbox-Pfade oder Apple-spezifische Flags ignorieren — Massen-Misses oder falsche Treffer.

Review-Mantra: Compilation Cache = innerhalb der Toolchain; DerivedData = innerhalb des Projekts; sccache/ccache = in der Organisation. Alle drei können koexistieren — mit expliziter Invalidierung und Pfadgrenzen. Sonst werden Trade-offs zwischen persistentem und Ephemeral-Runner durch Cache-Verschmutzung verdeckt. Grenzen des Pools: 2026 Exklusiver Fern-Mac, selbst gehostete CI: Persistenter Runner vs. Ephemeral-Runner-Pool — Cache-Warmup, Warteschlangen-Tail-Latenz, Credential-Injection und SSH-Observabilität: reproduzierbare Entscheidungsmatrix + FAQ.

2. Xcode 26 Compilation Cache: Wann „standardmäßig an“ reicht

In der Xcode-26-Generation zahlt sich Compilation Cache vor allem bei großen ObjC/Swift-Mischungen mit stabilen expliziten Modulen und einem CI-Knoten mit fester xcodebuild -version aus: Der zweite Vollbuild nach einem Clean Run verkürzt die Frontend-Zeit oft deutlich. Er ersetzt keine -derivedDataPath-Governance und keine SwiftPM-Neuauflösung bei driftenden Lockfiles.

Compilation Cache standardmäßig an, wenn:

• Persistenter Runner auf exklusivem Mac — oder pro Job eigenes DerivedData mit gemeinsamem read-only Compilation-Cache-Seed
• Explizite Module zwischen CI und lokaler Entwicklung abgestimmt (SWIFT_ENABLE_EXPLICIT_MODULES / gleiche Build Settings)
• Release-Pipelines priorisieren Reproduzierbarkeit gegenüber „letzte Cache-Schicht über alle PRs teilen“

Mit Isolation oder versionierter Invalidierung, wenn: mehrere Jobs ein Home-Verzeichnis teilen; Xcode-Minor-Upgrades wöchentlich rollen; Compliance einen Nachweis braucht, dass Output nur durch Commit-SHA + Lockfiles bestimmt ist — Cache-Wurzeln gehören auf eine versionierte Invalidierungsliste, nicht „nie ablaufen“.

3. Explizite Module: Voraussetzung für sinnvollen Compilation Cache

Explizite Module machen aus implizitem Scannen einen deklarierten Modulgraphen. Für CI bedeutet das stabilere Cache-Schlüssel, vorhersagbare Parallelität und Compilation-Cache-Treffer, die zur Absicht passen. Lokal aus / CI an (oder umgekehrt) liefert klassisch „CI grün, Laptop rot“ — meist Modulgraph-Mismatch, kein Flake.

Runbook-Checkliste:

1. Gleiche xcconfig oder Build Settings für xcodebuild und Xcode-GUI exportieren
2. Bei jedem Xcode-Upgrade Modul-Cache / Compilation Cache mitbumpen
3. Jedem parallelen Job eigenes -derivedDataPath; read-only SDK/Seed teilen, keine beschreibbaren Modul-Cache-Wurzeln

4. SPM-Blindspots: Warum Caches „an“ sind, Builds aber langsam bleiben

Swift Package Manager (Auflösung, Checkouts, Binärartefakte) ist nicht dieselbe Pipeline wie Clang Compilation Cache. Typische Lücken:

• Nicht committetes oder ungeprüftes Package.resolved — Abhängigkeitsgraph verschiebt sich pro Job
• Kontention auf ~/Library/Caches/org.swift.swiftpm — sporadische Auflösungsfehler oder langsame erste Minute
• Binärpakete + anderes Xcode — Compilation Cache rettet keinen SDK-Mismatch
• sccache-Schlüssel mit SPM-Pfaden ohne festes HOME — falsche Treffer auf SSH-headless-Knoten mit unterschiedlichen Home-Layouts

SPM-Policy separat behandeln: 2026 Exklusiver Fern-Mac iOS/macOS CI: SwiftPM Package.resolved — reproduzierbare Builds, Cache-Warmup, CI-Lock-Drift und SSH-Pipeline-Entscheidungsmatrix + FAQ. Compilation Cache und sccache erst einschalten, wenn der SPM-Graph gesperrt ist — sonst cachen Sie Rauschen.

5. sccache vs. ccache auf Remote-Mac-CI

Faustregel 2026 auf exklusivem Fern-Mac: ein persistenter Runner, kleines Team — oft reichen Compilation Cache + lokale DerivedData-Stufen; Mac-mini-Pool mit Branch-Explosion und gemeinsamen C/C++/Rust-Zielen — sccache-Remote-Buckets prüfen; Apple-Ziele der eingebauten Cache-Schicht überlassen; swiftc nicht doppelt wrappen ohne Triage-Story.

ccache passt weiter zu „eine Maschine + wenige native Deps“ oder Teams mit ccache-Erfahrung. Wer bereits Bazel-Remote-Cache auf Object Storage nutzt, kann bei sccache Bucket-Policy, IAM und Lifecycle-FinOps wiederverwenden.

6. Parallele Job-Verzeichnis-Isolation auf SSH-headless-Hosts

Exklusiver Mac ≠ ein gemeinsames DerivedData. Minimales Isolationsmodell:

• DERIVED_DATA_ROOT/$CI_JOB_ID — pro Job beschreibbar
• COMPILATION_CACHE_ROOT/v$XCODE_BUILD — read-only Mount oder Seed-Kopie pro Job
• SCCACHE_BUCKET_PREFIX/$REPO/$XCODE_BUILD/$BRANCH_POLICY — organisationsweit; Release- vs. PR-Buckets trennen
• TMPDIR und HOME pro Job überschreiben, damit CI-User globale Keychain- oder SPM-Caches nicht verschmutzen

SSH-Triage ohne GUI exportieren: xcodebuild -showBuildSettings, tatsächliches -derivedDataPath, Compilation-Cache-Pfad und sccache --show-stats. Pfade loggen, nicht nur „82 % Trefferquote“, um Misses zu erklären. Parallele Jobs, Simulator-Kontingente und Makro-Kompilierzeit: 2026 Exklusiver Fern-Mac-CI: Swift Testing (Makros) und XCTest im Mix — Kompilierzeit, Parallelität, Simulator-Kontingent und SSH-headless-Flakiness: Entscheidungsmatrix + FAQ.

7. Reproduzierbare Entscheidungsmatrix (ins Runbook kopieren)

Üblicher Hybrid 2026: Xcode-26 Compilation Cache an + pro Job eigenes DerivedData; sccache-Remote-Bucket für native Hilfslibs; SPM über Lockfiles und dedizierte Cache-Verzeichnisse wärmen; Release-Jobs mit explizitem „Cache invalidieren“ statt implizitem Ablauf.

8. FAQ

F1: Kollidiert Compilation Cache mit DerivedData-Löschung?

Nicht zwingend. DerivedData-Cleanup trifft Projektindex und Inkrementalzustand; Compilation Cache auf separatem Pfad kann als read-only Seed bleiben. Wenn ein Skript Modul-Cache und Compilation-Cache-Wurzeln gemeinsam rm -rf löscht, ist der nächste Build kalt — im Runbook was löschen, was behalten festhalten.

F2: Ist das Wrappen des gesamten xcodebuild mit sccache sicher?

Nein — nicht den kompletten xcodebuild-Baum an sccache übergeben. Nur explizite clang/swiftc-Aufrufe aus CMake/Bazel/Rust-Subzielen wrappen; Apple-Hauptziele der eingebauten Cache-Schicht und korrekten DerivedData-Isolation überlassen.

F3: Hohe Trefferquote, aber nicht reproduzierbar?

Remote-Sharing stoppen, Package.resolved und Xcode pinnen, per SSH Clean Build vs. Cache-Build diffen. Typisch: Hash ohne SDK-Pfade, Makros oder Branch-Namen → falsche Treffer. Release-Pipelines brauchen sccache-Bypass per Klick (SCCACHE_DIRECT=1 oder Wrapper entfernen).

F4: Brauchen zwei parallele Jobs zwei Macs?

Nein — aber beschreibbare Verzeichnisse müssen isoliert sein. Zwei Jobs auf einem M4 Mac mini kämpfen eher um I/O und Simulatoren als um eine gemeinsame read-only Compilation-Cache-Schicht. Warteschlangen-Limits schlagen oft blindes Aufstocken.

F5: Wie rechtfertige ich Object-Storage-Kosten?

sccache-Bucket-Kosten neben „eingesparten Runner-Minuten“ in einer FinOps-Tabelle: Remote-Cache spart maschinenübergreifend wiederholte Kompilierung; Compilation Cache spart Frontend-Wiederholung auf einer Maschine. Falsch gestapelt kaufen Sie mysteriöse grüne Builds und mehr On-Call — die Matrix mappt Ausgaben auf beobachtbare Treffer.

Alle drei Cache-Ebenen auf Hardware, die per SSH erreichbar ist

Compilation Cache, sccache und DerivedData-Policy landen auf Apple Silicon, die 24/7 kompiliert und SSH-Triage akzeptiert. Mac mini M4 mit niedrigem Leerlauf (~4 W) und leisem Gehäuse eignet sich für Desk- oder Rack-Pools; natives macOS + Xcode reduziert die „Laptop schnell, CI langsam“-Toolchain-Lücke.

Unified Memory hilft großen iOS-Jobs unter Compile + Tests + Simulator ohne ständiges Paging; Gatekeeper, SIP und FileVault geben unbeaufsichtigten Knoten eine verteidigbare Standard-Sicherheit. Sind explizite Module, SPM-Lockfiles und Job-Verzeichnisse im Runbook, ist der Mac mini die Hardware-Baseline, die diese Regeln hält — kein weiteres undurchsichtiges Kästchen.

Wer Xcode-26 Compilation Cache und Remote-sccache-Buckets gemeinsam ausrollt und einen kleinen, login-freundlichen Host für die ganze exklusive Pipeline sucht, findet im Mac mini M4 2026 weiter einen der besten Preis/Leistungs-Einstiege — Cache-Stufen zuerst auf echter Hardware validieren, dann Runner-Zahl skalieren.