Otimização de Desempenho SwiftUI
Quando Usar Esta Skill
Use quando:
- O app parece menos responsivo (travamentos, engasgos, rolagem atrasada)
- Animações pausam ou pulam durante a execução
- O desempenho da rolagem é ruim
- A criação de perfil revela que o SwiftUI é o gargalo
- Os bodies das views estão demorando muito para serem executados
- As views estão sendo atualizadas com mais frequência do que o necessário
- É necessário entender a causa e o efeito das atualizações do SwiftUI
Exemplos de Prompts
Estas são perguntas reais que desenvolvedores fazem e que esta skill foi projetada para responder:
1. "Meu app tem rolagem instável e animações estão gaguejando. Como descubro se o SwiftUI é a causa?"
→ A skill mostra como usar o novo instrumento SwiftUI no Instruments 26 para identificar se o SwiftUI é o gargalo em comparação com outras camadas
2. "Estou usando o novo instrumento SwiftUI e vejo barras laranja/vermelhas mostrando atualizações longas. Como sei o que as está causando?"
→ A skill aborda os padrões do Gráfico de Causa e Efeito que mostram o fluxo de dados através do seu app e quais mudanças de estado disparam atualizações caras
3. "Algumas views estão sendo atualizadas com muita frequência, mesmo que seus dados não tenham mudado. Como encontro quais views são o problema?"
→ A skill demonstra a detecção de atualizações desnecessárias e a solução de problemas de Identidade com a linha do tempo visual
4. "Tenho estruturas de dados grandes e hierarquias de views complexas. Como otimizá-las para o desempenho do SwiftUI?"
→ A skill cobre padrões de desempenho: dividir hierarquias de views, minimizar a complexidade do body e usar a lista de verificação de otimização @Sendable
5. "Temos um prazo de desempenho e preciso entender o que está lento no SwiftUI. Quais são as métricas críticas?"
→ A skill fornece a árvore de decisão para priorizar otimizações e entende cenários de pressão com orientação profissional para compensações
Visão Geral
Princípio Central: Garanta que os bodies das suas views sejam atualizados rapidamente e apenas quando necessário para alcançar um ótimo desempenho do SwiftUI.
NOVO na WWDC 2025: O instrumento SwiftUI de próxima geração no Instruments 26 fornece análise de desempenho abrangente com:
- Linha do tempo visual de atualizações longas (codificadas por cores laranja/vermelho por gravidade)
- Gráfico de Causa e Efeito mostrando o fluxo de dados através do seu app
- Integração com o Time Profiler para análise de CPU
- Rastreamento de Engasgos e Travamentos (Hangs and Hitches)
Principais Problemas de Desempenho:
- Atualizações Longas do Body da View — Bodies de views demorando muito para serem executados
- Atualizações Desnecessárias de Views — Views sendo atualizadas quando os dados não mudaram realmente
Melhorias de Desempenho do Framework iOS 26
"Melhorias de desempenho no framework beneficiam apps em todas as plataformas da Apple, do nosso app ao seu." — WWDC 2025-256
O SwiftUI no iOS 26 inclui grandes ganhos de desempenho que beneficiam todos os apps automaticamente. Essas melhorias funcionam em conjunto com as novas ferramentas de criação de perfil para tornar o SwiftUI mais rápido pronto para uso.
Desempenho de List (Foco em macOS)
Ganhos massivos para listas grandes
- Carregamento 6x mais rápido para listas de 100.000+ itens no macOS
- Atualizações 16x mais rápidas para listas grandes
- Ganhos ainda maiores para listas maiores
- As melhorias beneficiam todas as plataformas (iOS, iPadOS, watchOS, não apenas macOS)
List(trips) { trip in // 100k+ itens
TripRow(trip: trip)
}
// iOS 26: Carrega 6x mais rápido, atualiza 16x mais rápido no macOS
// Todas as plataformas se beneficiam das melhorias de desempenho
Impacto no seu app
- Grandes conjuntos de dados (10k+ itens) veem melhorias notáveis
- Operações de filtragem e classificação são concluídas mais rapidamente
- Atualizações em tempo real para listas são mais responsivas
- Beneficia apps como navegadores de arquivos, listas de contatos, tabelas de dados
Desempenho de Rolagem
Redução de quadros perdidos durante rolagem em alta velocidade
O SwiftUI melhorou o agendamento de atualizações da interface do usuário no iOS e macOS. Isso melhora a responsividade e permite que o SwiftUI faça ainda mais trabalho para se preparar para os próximos quadros. No geral, reduz a chance de seu app perder um quadro ao rolar rapidamente em altas taxas de quadros.
Principais melhorias
- Melhor agendamento de quadros — O SwiftUI ganha mais tempo para se preparar para os próximos quadros
- Responsividade aprimorada — Atualizações da interface agendadas com mais eficiência
- Menos quadros perdidos — Especialmente durante rolagem rápida a 120Hz (ProMotion)
Quando você notará
- Rolando por conteúdo com muitas imagens
- Dispositivos com alta taxa de quadros (iPhone Pro, iPad Pro com ProMotion)
- Linhas de lista complexas com várias views
ScrollViews Aninhadas com Lazy Stacks
Carrosséis de fotos e rolagem multieixo agora otimizam corretamente
ScrollView(.horizontal) {
LazyHStack {
ForEach(photoSets) { photoSet in
ScrollView(.vertical) {
LazyVStack {
ForEach(photoSet.photos) { photo in
PhotoView(photo: photo)
}
}
}
}
}
}
// iOS 26: ScrollViews aninhadas agora atrasam corretamente o carregamento com lazy stacks
// Ótimo para carrosséis de fotos, layouts estilo Netflix, conteúdo multieixo
Antes do iOS 26 ScrollViews aninhadas não atrasavam corretamente o carregamento do conteúdo de lazy stacks, fazendo com que todo o conteúdo aninhado carregasse imediatamente.
Após o iOS 26 Lazy stacks dentro de ScrollViews aninhadas agora atrasam o carregamento até que o conteúdo esteja prestes a aparecer, correspondendo ao comportamento de ScrollViews de nível único.
Casos de uso
- Galerias de fotos com rolagem horizontal/vertical
- Linhas de categorias estilo Netflix
- Navegadores de dados multidimensionais
- Carrosséis de imagens com rolagem vertical de detalhes
Aprimoramentos do Instrumento de Desempenho SwiftUI
Novas faixas no Instruments 26
O instrumento SwiftUI agora inclui faixas dedicadas para:
- Atualizações Longas do Body da View — Identifique computações caras do body
- Atualizações Longas de View da Plataforma — Acompanhe o desempenho da ponte UIKit/AppKit (Atualizações Longas de Representable)
- Outras Atualizações Longas — Todos os outros tipos de trabalho SwiftUI longo
Essas faixas são abordadas em detalhes na próxima seção.
Resumo das Melhorias de Desempenho
Ganhos automáticos (apenas recompilar)
- ✅ Carregamento de lista 6x mais rápido (100k+ itens, macOS)
- ✅ Atualizações de lista 16x mais rápidas (macOS)
- ✅ Redução de quadros perdidos durante a rolagem
- ✅ Melhor agendamento de quadros no iOS/macOS
- ✅ Otimização de carregamento lento em ScrollView aninhada
Nenhuma alteração de código necessária — recompile com o SDK do iOS 26 para obter essas melhorias.
Referência cruzada SwiftUI 26 Features (skill swiftui-26-ref) — Guia abrangente para todas as mudanças do SwiftUI no iOS 26
O Instrumento SwiftUI (Instruments 26)
Primeiros Passos
Requisitos:
- Instalar Xcode 26
- Atualizar dispositivos para as versões mais recentes do sistema operacional (suporte para gravação de traces SwiftUI)
- Compilar o app em modo Release para uma criação de perfil precisa
Inicialização:
- Abra o projeto no Xcode
- Pressione Command-I para criar perfil
- Escolha SwiftUI template no seletor de templates
- Clique no botão Record
Conteúdo do Template
O template SwiftUI inclui três instrumentos:
- Instrumento SwiftUI (NOVO) — Identifica problemas de desempenho no código SwiftUI
- Time Profiler — Mostra amostras de trabalho da CPU ao longo do tempo
- Hangs and Hitches — Rastreia a responsividade do app
Faixas do Instrumento SwiftUI
Faixa 1: Update Groups (Grupos de Atualização)
- Mostra quando o SwiftUI está ativamente trabalhando
- Vazio durante picos de CPU? → O problema provavelmente está fora do SwiftUI
Faixa 2: Long View Body Updates (Atualizações Longas do Body da View)
- Destaca quando a propriedade
bodyleva muito tempo - O problema de desempenho mais comum — comece aqui
Faixa 3: Long Representable Updates (Atualizações Longas de Representable)
- Identifica atualizações lentas de UIViewRepresentable/NSViewRepresentable
- Desempenho da integração UIKit/AppKit
Faixa 4: Other Long Updates (Outras Atualizações Longas)
- Todos os outros tipos de trabalho SwiftUI longo
Sistema de Codificação por Cores
As atualizações são mostradas em laranja e vermelho com base na probabilidade de causar engasgos (hitches):
- Vermelho — Muito provável de contribuir para um engasgo/travamento (investigue primeiro)
- Laranja — Moderadamente provável de causar problemas
- Cinza — Atualizações normais, não preocupantes
Nota: Se as atualizações realmente resultam em engasgos depende das condições do dispositivo, mas as atualizações vermelhas são a maior prioridade.
Entendendo o Loop de Renderização
Renderização Normal de Quadro
Quadro 1:
├─ Lidar com eventos (toques, pressionamentos de tecla)
├─ Atualizar UI (executar bodies de views)
│ └─ Concluir antes do prazo do quadro ✅
├─ Entregar ao sistema
└─ Sistema renderiza → Visível na tela
Quadro 2:
├─ Lidar com eventos
├─ Atualizar UI
│ └─ Concluir antes do prazo do quadro ✅
├─ Entregar ao sistema
└─ Sistema renderiza → Visível na tela
Resultado: Animações suaves e fluidas
Quadro com Engasgo (Body de View Longo)
Quadro 1:
├─ Lidar com eventos
├─ Atualizar UI
│ └─ UM BODY DE VIEW MUITO LENTO
│ └─ Executa além do prazo do quadro ❌
├─ Perde o prazo
└─ Quadro anterior permanece visível (ENGASGO)
Quadro 2: (Atrasado)
├─ Lidar com eventos (atrasados em 1 quadro)
├─ Atualizar UI
├─ Entregar ao sistema
└─ Sistema renderiza → Finalmente visível
Resultado: Quadro anterior visível por 2+ quadros = gagueira na animação
Quadro com Engasgo (Muitas Atualizações)
Quadro 1:
├─ Lidar com eventos
├─ Atualizar UI
│ ├─ Atualização 1 (rápida)
│ ├─ Atualização 2 (rápida)
│ ├─ Atualização 3 (rápida)
│ ├─ ... (100 atualizações rápidas adicionais)
│ └─ Tempo total excede o prazo ❌
├─ Perde o prazo
└─ Quadro anterior permanece visível (ENGASGO)
Resultado: Muitas pequenas atualizações se somam para perder o prazo
Insight Chave: O tempo de execução do body da view é importante porque perder prazos de quadros causa engasgos, tornando as animações menos fluidas.
Referência:
- Understanding hitches in your app
- Tech Talk sobre o loop de renderização e correção de engasgos
Problema 1: Atualizações Longas do Body da View
Identificando Atualizações Longas
- Grave um trace no Instruments com o template SwiftUI
- Observe a faixa Long View Body Updates — há barras laranja/vermelhas?
- Expanda a faixa SwiftUI para ver as subfaixas
- Selecione a subfaixa View Body Updates
- Filtre para atualizações longas:
- Painel de detalhes → Menu suspenso → Escolha "Long View Body Updates summary"
Analisando com o Time Profiler
Fluxo de trabalho:
- Encontre uma atualização longa no resumo Long View Body Updates
- Passe o mouse sobre o nome da view → Clique na seta → "Show Updates"
- Clique com o botão direito na atualização longa → "Set Inspection Range and Zoom"
- Mude para a faixa do instrumento Time Profiler
O que você vê:
- Pilhas de chamadas para amostras gravadas durante a execução do body da view
- Tempo gasto em cada quadro (coluna mais à esquerda)
- Seu body de view aninhado em uma pilha de chamadas SwiftUI profunda
Encontrando o gargalo:
- Option-clique para expandir a pilha de chamadas da thread principal
- Command-F para pesquisar pelo nome da sua view (ex.: "LandmarkListItemView")
- Identifique operações caras na coluna de tempo
Operações Caras Comuns
Criação de Formatadores (Muito Caro)
❌ ERRADO - Criando formatadores no body da view:
struct LandmarkListItemView: View {
let landmark: Landmark
@State private var userLocation: CLLocation
var distance: String {
// ❌ Criando formatadores toda vez que o body é executado
let numberFormatter = NumberFormatter()
numberFormatter.maximumFractionDigits = 1
let measurementFormatter = MeasurementFormatter()
measurementFormatter.numberFormatter = numberFormatter
let meters = userLocation.distance(from: landmark.location)
let measurement = Measurement(value: meters, unit: UnitLength.meters)
return measurementFormatter.string(from: measurement)
}
var body: some View {
HStack {
Text(landmark.name)
Text(distance) // Chama a propriedade distance cara
}
}
}
Por que é lento:
- Formatadores são caros de criar (milissegundos cada)
- Criados toda vez que o body da view é executado
- Executa na thread principal → o app espera antes de continuar as atualizações da UI
- Múltiplas views → o tempo soma rapidamente
✅ CORRETO - Armazene formatadores em cache centralmente:
@Observable
class LocationFinder {
private let formatter: MeasurementFormatter
private let landmarks: [Landmark]
private var distanceCache: [Landmark.ID: String] = [:]
init(landmarks: [Landmark]) {
self.landmarks = landmarks
// Cria formatadores UMA VEZ durante a inicialização
let numberFormatter = NumberFormatter()
numberFormatter.maximumFractionDigits = 1
self.formatter = MeasurementFormatter()
self.formatter.numberFormatter = numberFormatter
updateDistances()
}
func didUpdateLocations(_ locations: [CLLocation]) {
guard let location = locations.last else { return }
updateDistances(from: location)
}
private func updateDistances(from location: CLLocation? = nil) {
guard let location else { return }
for landmark in landmarks {
let meters = location.distance(from: landmark.location)
let measurement = Measurement(value: meters, unit: UnitLength.meters)
distanceCache[landmark.id] = formatter.string(from: measurement)
}
}
func distanceString(for landmarkID: Landmark.ID) -> String {
distanceCache[landmarkID] ?? "Unknown"
}
}
struct LandmarkListItemView: View {
let landmark: Landmark
@Environment(LocationFinder.self) private var locationFinder
var body: some View {
HStack {
Text(landmark.name)
Text(locationFinder.distanceString(for: landmark.id)) // ✅ Consulta rápida
}
}
}
Benefícios:
- Formatadores criados uma vez, reutilizados para todos os landmarks
- Strings pré-calculadas quando a localização muda
- O body da view apenas lê o valor em cache (instantâneo)
- Atualizações longas do body da view eliminadas
Outras Operações Caras
Cálculos Complexos:
// ❌ Não calcule no body da view
var body: some View {
let result = expensiveAlgorithm(data) // Matemática complexa, ordenação, etc.
Text("\(result)")
}
// ✅ Calcule no modelo, armazene em cache
@Observable
class ViewModel {
private(set) var result: Int = 0
func updateData(_ data: [Int]) {
result = expensiveAlgorithm(data) // Calcule uma vez
}
}
I/O de Rede/Arquivo:
// ❌ NUNCA faça I/O no body da view
var body: some View {
let data = try? Data(contentsOf: fileURL) // ❌ I/O síncrono
// ...
}
// ✅ Carregue assincronamente e armazene
…
[truncado para tradução]
Identidade e Atualizações Desnecessárias
(O restante do conteúdo aborda identidade, atualizações desnecessárias, ferramentas de diagnóstico e otimizações avançadas; por favor, continue com a tradução seguindo o mesmo padrão.)