A matemática real dos builds lentos em macOS
Em projetos iOS com dezenas de módulos e alguns anos de estrada, é assustadoramente comum encontrar pipelines de validação de Pull Request levando de 40 a 55 minutos. Muita gente se acostuma com essa lentidão como se fosse uma lei da natureza do Xcode, até colocar o impacto na ponta do lápis.
O prejuízo bate em duas frentes ao mesmo tempo. Na fatura de infraestrutura, minutos de runners macOS em nuvem costumam custar de cinco a dez vezes mais do que minutos de máquinas Linux equivalentes. No lado humano, que quase sempre sai mais caro, um pipeline de 45 minutos quebra completamente o foco do desenvolvedor: você abre o PR, muda para outra tarefa enquanto espera, recebe uma falha de lint ou teste uma hora depois e perde mais quinze minutos retomando o raciocínio original. Em uma equipe de 12 pessoas abrindo dois PRs por dia, reduzir o build de 45 para 10 minutos devolve dezenas de horas úteis toda semana. Se quiser simular esse custo com os números da sua equipe (tamanho do time, PRs por dia e tarifa do runner), use a calculadora interativa de ROI de CI/CD disponível aqui no site.
Alvo pragmático de produtividade: um pipeline de validação de Pull Request em iOS deveria fechar entre 8 e 12 minutos. Acima de 20 minutos, o time começa a agrupar mudanças grandes demais em um único PR para evitar a espera, o que piora a qualidade das revisões e aumenta o risco de regressão.
Meça antes de otimizar: perfilando cada etapa
O primeiro erro de quem tenta acelerar um pipeline é sair aplicando receitas prontas de cache sem medir onde o relógio realmente está parado. Em vários projetos que auditei, a equipe jurava que o gargalo era o compilador Swift, quando na verdade 14 minutos estavam indo embora baixando dependências externas sem cache, 6 minutos ligando um simulador frio e mais 5 minutos rodando scripts de geração de assets que nem precisavam executar em build de teste unitário.
Antes de mexer no YAML do CI, execute uma compilação limpa com o resumo de tempos do próprio xcodebuild e colete os tempos por fase do runner:
# Medir quanto cada etapa e cada target consome na compilação
xcodebuild build-for-testing \
-workspace App.xcworkspace \
-scheme AppTests \
-destination 'platform=iOS Simulator,name=iPhone 16,OS=latest' \
-showBuildTimingSummary Com o relatório em mãos, separe o tempo total em cinco blocos: checkout e setup do ambiente, resolução de dependências (SPM/CocoaPods), compilação e linkagem, inicialização do simulador e execução da suíte de testes. Ataque sempre o maior bloco primeiro.
Alavancas de otimização e impacto real
A tabela abaixo resume as otimizações que costumam entregar maior redução de tempo em projetos iOS médios e grandes, junto com o risco operacional de cada escolha:
| Técnica | Ganho típico por build | Esforço de implantação | Risco ou trade-off principal |
|---|---|---|---|
| Cache de SPM / Pods e ferramentas (Bundler/Mint) | 3 a 9 minutos | Baixo (1 dia) | Chave de cache mal montada causa miss frequente ou dependências obsoletas. |
| Pré-compilar SDKs pesados em XCFramework | 4 a 12 minutos | Médio (2 a 4 dias) | Exige recompilar os binários quando a versão do Xcode ou do SDK muda. |
build-for-testing + sharding de testes | 8 a 25 minutos | Médio (3 a 5 dias) | Consome mais concorrência de runners paralelos; requer testes independentes entre si. |
| Corrigir expressões lentas no type-checker Swift | 2 a 8 minutos | Baixo a médio | Nenhum risco de cache; melhora também o build local na máquina de cada dev. |
| Desligar Run Scripts desnecessários em Debug/Test | 1 a 5 minutos | Baixo (meio dia) | Garantir que upload de dSYM e checagens de release continuem ativos em Archive. |
Cache que funciona de verdade (e a armadilha do DerivedData)
Uma dica repetida em muitos blogs é colocar toda a pasta ~/Library/Developer/Xcode/DerivedData dentro do cache do GitHub Actions ou GitLab CI. Na prática, isso frequentemente piora o tempo total do pipeline. Em um projeto grande, o DerivedData passa facilmente de 4 GB a 8 GB. Comprimir, enviar pela rede ao fim do job e descompactar esse volume no job seguinte pode consumir seis minutos sozinho, além de provocar erros estranhos de módulos pré-compilados incompatíveis quando o caminho absoluto ou o timestamp muda entre runners efêmeros.
Em runners efêmeros na nuvem, o cache que realmente se paga é enxuto e determinístico: o diretório de checkouts do Swift Package Manager (usando a flag -clonedSourcePackagesDirPath), as gems do Ruby/Fastlane e binários pré-compilados de terceiros que raramente mudam. Deixe o cache de compilação incremental para máquinas Apple Silicon dedicadas (self-hosted) ou para ferramentas de cache remoto baseadas em hash de conteúdo (como Tuist Cache ou Bazel).
# Exemplo enxuto no GitHub Actions: cache determinístico de SPM sem inflar o runner
- name: Cache Swift Package Manager checkouts
uses: actions/cache@v4
with:
path: SourcePackages
key: ${{ runner.os }}-spm-${{ hashFiles('**/Package.resolved') }}
restore-keys: |
${{ runner.os }}-spm-
- name: Compilar uma única vez para testes
run: |
xcodebuild build-for-testing \
-workspace App.xcworkspace \
-scheme AppPRValidation \
-destination 'platform=iOS Simulator,name=iPhone 16,OS=latest' \
-clonedSourcePackagesDirPath SourcePackages \
-derivedDataPath BuildOutput \
COMPILER_INDEX_STORE_ENABLE=NO Repare na opção COMPILER_INDEX_STORE_ENABLE=NO no comando acima. O índice usado pelo autocomplete e navegação do Xcode não tem utilidade alguma dentro de um servidor de CI, mas costuma adicionar de 10% a 18% de sobrecarga de CPU e disco durante a compilação. Desligá-lo no CI economiza minutos de graça e ainda reduz o tamanho do artefato gerado.
Build uma vez, teste em paralelo
Quando a suíte passa de 2.500 testes unitários ou inclui dezenas de testes de interface, rodar tudo em fila única vira o principal gargalo. O segredo para escalar em matriz no CI sem pagar a conta da compilação várias vezes é quebrar o fluxo em dois estágios: o primeiro job executa build-for-testing e publica o diretório Build/Products (que contém o arquivo .xctestrun); em seguida, três ou quatro jobs paralelos baixam esse artefato e executam test-without-building, cada um rodando um .xctestplan ou um conjunto diferente de targets.
# Execução paralela em workers usando artefato já compilado
xcodebuild test-without-building \
-xctestrun BuildOutput/Build/Products/AppPRValidation_iphonesimulator*.xctestrun \
-destination 'platform=iOS Simulator,name=iPhone 16,OS=latest' \
-only-testing:CoreNetworkingTests \
-only-testing:PaymentsDomainTests \
-parallel-testing-enabled YES \
-parallel-testing-worker-count 3 \
-resultBundlePath TestResults-Shard1.xcresult Um detalhe importante de ajuste fino: não chute um número alto em -parallel-testing-worker-count. Em uma VM macOS com 3 ou 4 vCPUs, subir 6 clones de simuladores ao mesmo tempo gera contenção pesada de memória e I/O, deixando os testes mais lentos e intermitentes do que com 2 ou 3 workers. Teste na prática com 2, 3 e 4 workers e escolha o menor tempo médio estável. E lembre que paralelização exige isolamento rigoroso de rede e estado, como detalhado em ambientes herméticos de teste com mock servers.
Em bases maiores, a arquitetura do código também ajuda diretamente o CI. Se o projeto estiver bem dividido em módulos independentes (como discutido em arquitetura modular em iOS), um script simples baseado em git diff consegue identificar quais módulos foram tocados no Pull Request e executar primeiro apenas os testes daqueles módulos e de quem depende deles, reservando a suíte completa para a fila de merge.
Caçando gargalos escondidos no compilador Swift
Muitas vezes a lentidão do build vem de uma dúzia de arquivos específicos onde a inferência de tipos do Swift explode em complexidade exponencial. Operadores ternários encadeados, somas de arrays grandes em uma única expressão, dicionários literais extensos sem anotação de tipo e views SwiftUI gigantescas costumam travar um núcleo inteiro do processador por 10 a 30 segundos.
Adicione temporariamente estas flags nas configurações do target em Debug para listar exatamente quais funções e expressões passam de 100 milissegundos:
// Em Build Settings > Other Swift Flags (apenas Debug/Diagnóstico)
OTHER_SWIFT_FLAGS = -Xfrontend -warn-long-function-bodies=100 -Xfrontend -warn-long-expression-type-checking=100 Em um caso real que corrigi, uma única função que montava um dicionário de parâmetros analíticos com operadores ?? aninhados consumia 19 segundos a cada compilação incremental. Bastou declarar o tipo explícito var payload: [String: Any] = [:] e quebrar a montagem em atribuições diretas para o tempo daquele arquivo cair de 19 segundos para 40 milissegundos. Também confira se o esquema usado em validação de PR compila com SWIFT_COMPILATION_MODE = incremental (ou singlefile) e nível de otimização -Onone; deixar wholemodule e -O ligados em jobs de teste unitário duplica o tempo de compilação sem necessidade.
Plano prático de quatro semanas
Se o seu pipeline hoje passa de 35 minutos, não tente reescrever tudo em um fim de semana. Um plano gradual entrega retorno já na primeira sprint:
- Na primeira semana, colete os tempos das últimas 50 execuções, rode
-showBuildTimingSummarye liste os três maiores ofensores reais do pipeline. - Na segunda semana, ative cache de
SourcePackagese gems, incluaCOMPILER_INDEX_STORE_ENABLE=NOe impeça que Run Scripts exclusivos de release (como upload de dSYMs) rodem em builds de teste. - Na terceira semana, ligue as flags de diagnóstico do Swift, corrija as 15 funções mais lentas do projeto e avalie empacotar SDKs de terceiros estáveis como XCFramework pré-compilado.
- Na quarta semana, separe
build-for-testingdetest-without-building, ajuste o número de workers paralelos ao hardware real do runner e acompanhe semanalmente os percentis p50 e p90 do tempo de build para barrar regressões silenciosas.
