Communitygithub.com

ComeOnOliver/skillshub

Use quando a UI está lenta, a rolagem trava, animações gaguejam, ou ao perguntar 'por que minha view SwiftUI está lenta', 'como otimizar o desempenho de List', 'meu app dropa quadros', 'o body da view é chamado com muita frequência', 'List está lenta' - otimização de desempenho SwiftUI com Instruments 26 e padrões WWDC 2025

O que é skillshub?

Este guia abrangente de otimização de desempenho SwiftUI foi projetado para ajudar desenvolvedores a diagnosticar e corrigir problemas de desempenho em seus aplicativos Apple. Ele se concentra no uso do novo instrumento SwiftUI no Xcode 26 e nos padrões apresentados na WWDC 2025 para identificar, analisar e resolver dois problemas principais: atualizações lentas do body de views e atualizações desnecessárias de views. O guia fornece instruções passo a passo para usar o template SwiftUI no Instruments, incluindo a análise de faixas coloridas (vermelho/laranja para problemas graves) e o uso do Time Profiler para encontrar gargalos computacionais. Ele também aborda otimizações automáticas de desempenho introduzidas no iOS 26, como carregamento 6x mais rápido de listas e redução de quadros perdidos durante a rolagem, e práticas recomendadas como evitar a criação de objetos caros (como formatadores) no body da view e armazenar cálculos complexos em cache no modelo. Além disso, explica conceitos fundamentais como o loop de renderização e o 'render loop' para entender por que as violações de prazo causam 'hitches' (travamentos), capacitando os desenvolvedores a priorizar correções de forma eficaz e oferecer uma experiência de usuário mais fluida.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ComeOnOliver/skillshub/tree/HEAD/skills/CharlesWiltgen/Axiom/axiom-swiftui-performance

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

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:

  1. Atualizações Longas do Body da View — Bodies de views demorando muito para serem executados
  2. 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

  1. Melhor agendamento de quadros — O SwiftUI ganha mais tempo para se preparar para os próximos quadros
  2. Responsividade aprimorada — Atualizações da interface agendadas com mais eficiência
  3. 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:

  1. Atualizações Longas do Body da View — Identifique computações caras do body
  2. Atualizações Longas de View da Plataforma — Acompanhe o desempenho da ponte UIKit/AppKit (Atualizações Longas de Representable)
  3. 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:

  1. Abra o projeto no Xcode
  2. Pressione Command-I para criar perfil
  3. Escolha SwiftUI template no seletor de templates
  4. Clique no botão Record

Conteúdo do Template

O template SwiftUI inclui três instrumentos:

  1. Instrumento SwiftUI (NOVO) — Identifica problemas de desempenho no código SwiftUI
  2. Time Profiler — Mostra amostras de trabalho da CPU ao longo do tempo
  3. 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 body leva 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:


Problema 1: Atualizações Longas do Body da View

Identificando Atualizações Longas

  1. Grave um trace no Instruments com o template SwiftUI
  2. Observe a faixa Long View Body Updates — há barras laranja/vermelhas?
  3. Expanda a faixa SwiftUI para ver as subfaixas
  4. Selecione a subfaixa View Body Updates
  5. Filtre para atualizações longas:
    • Painel de detalhes → Menu suspenso → Escolha "Long View Body Updates summary"

Analisando com o Time Profiler

Fluxo de trabalho:

  1. Encontre uma atualização longa no resumo Long View Body Updates
  2. Passe o mouse sobre o nome da view → Clique na seta → "Show Updates"
  3. Clique com o botão direito na atualização longa → "Set Inspection Range and Zoom"
  4. 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:

  1. Option-clique para expandir a pilha de chamadas da thread principal
  2. Command-F para pesquisar pelo nome da sua view (ex.: "LandmarkListItemView")
  3. 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.)

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ComeOnOliver/skillshub

Create stunning, animation-rich HTML presentations from scratch or by converting PowerPoint files. Use when the user wants to build a presentation, convert a PPT/PPTX to web, or create slides for a talk/pitch. Helps non-designers discover their aesthetic through visual exploration rather than abstract choices.

ComeOnOliver/skillshub

Next.js 16+ 和 Turbopack — 增量打包、文件系统缓存、开发速度,以及何时使用 Turbopack 与 webpack。

ComeOnOliver/skillshub

SwiftUI architecture patterns, state management with @Observable, view composition, navigation, performance optimization, and modern iOS/macOS UI best practices.

ComeOnOliver/skillshub

See, Understand, Act on video and audio. See- ingest from local files, URLs, RTSP/live feeds, or live record desktop; return realtime context and playable stream links. Understand- extract frames, build visual/semantic/temporal indexes, and search moments with timestamps and auto-clips. Act- transcode and normalize (codec, fps, resolution, aspect ratio), perform timeline edits (subtitles, text/image overlays, branding, audio overlays, dubbing, translation), generate media assets (image, audio, video), and create real time alerts for events from live streams or desktop capture.

ComeOnOliver/skillshub

AI-assisted video editing workflows for cutting, structuring, and augmenting real footage. Covers the full pipeline from raw capture through FFmpeg, Remotion, ElevenLabs, fal.ai, and final polish in Descript or CapCut. Use when the user wants to edit video, cut footage, create vlogs, or build video content.

ComeOnOliver/skillshub

Next.js 15 애플리케이션을 위한 프론트엔드 개발 가이드라인. React 19, TypeScript, Shadcn/ui, Tailwind CSS를 사용한 모던 패턴. Server Components, Client Components, App Router, 파일 구조, Shadcn/ui 컴포넌트, 성능 최적화, TypeScript 모범 사례 포함. 컴포넌트, 페이지, 기능 생성, 데이터 페칭, 스타일링, 라우팅, 프론트엔드 코드 작업 시 사용.

ComeOnOliver/skillshub

Provides Tamagui patterns for config v4, compiler optimization, styled context, and cross-platform styling. Must use when working with Tamagui projects (tamagui.config.ts, @tamagui imports).

ComeOnOliver/skillshub

Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

ComeOnOliver/skillshub

Create high-converting, visually distinctive landing pages. Use when building marketing pages, product launches, SaaS homepages, or any single-page conversion-focused website. Guides section-by-section composition with anti-AI-slop principles.

ComeOnOliver/skillshub

Auto-loaded context for Portfolio Buddy 2 development. Use for ANY task involving: React 19 development, TypeScript, portfolio analysis features, metrics calculations, trading strategy comparison, or working with the Portfolio Buddy 2 codebase. Contains tech stack, known issues, and architectural constraints.

ComeOnOliver/skillshub

Next.js development tooling via MCP. Inspect routes, components, build info, and debug Next.js apps. Use when working on Next.js applications, debugging routing, or inspecting app structure. NOT for general React or non-Next.js projects.

ComeOnOliver/skillshub

Implement UI using Shadcn MCP (atoms/theme) and 21st.dev MCP (complex sections). Use when adding buttons, layouts, or generating landing pages.

ComeOnOliver/skillshub

A conceptual skill for building an API client in Next.js that handles JWT tokens

ComeOnOliver/skillshub

Best practices and patterns for Next.js App Router, Server Actions, and Routing in this project.

ComeOnOliver/skillshub

The Design System, Theme, and UX rules for the Physical AI Hub.

ComeOnOliver/skillshub

Comprehensive frontend development skill for building modern, performant web applications using ReactJS, NextJS, TypeScript, Tailwind CSS. Includes component scaffolding, performance optimization, bundle analysis, and UI best practices. Use when developing frontend features, optimizing performance, implementing UI/UX designs, managing state, or reviewing frontend code.

ComeOnOliver/skillshub

This document captures learnings from fixing keyboard navigation issues when floating components (Select, DropdownMenu, Popover) have CSS open/close animations.

ComeOnOliver/skillshub

Build Next.js 16 applications with correct patterns and distinctive design. Use when creating pages, layouts, dynamic routes, upgrading from Next.js 15, or implementing proxy.ts. Covers breaking changes (async params/searchParams, Turbopack, cacheComponents) and frontend aesthetics. NOT when building non-React or backend-only applications.

ComeOnOliver/skillshub

Comprehensive Framer Motion animation library for React. Covers motion components, variants, gestures, page transitions, and scroll animations. Use when adding animations to React/Next.js applications.

ComeOnOliver/skillshub

Build interfaces that resonate, not just render. This skill enforces bold, intentional

Habilidades Relacionadas