Communitygithub.com

ComeOnOliver/skillshub

SwiftUI-Leistungsoptimierung mit Instruments 26 und WWDC 2025-Mustern – verwenden bei träger UI, ruckelndem Scrollen, stotternden Animationen oder Fragen zur SwiftUI-Performance.

Was ist skillshub?

Diese Fertigkeit bietet eine umfassende Anleitung zur Optimierung der SwiftUI-Leistung unter Verwendung der neuen Instrumente aus WWDC 2025 und Instruments 26. Sie identifiziert zwei Hauptprobleme: lange Aktualisierungen von View-Bodies und unnötige View-Updates, die zu Rucklern und Hängern führen können. Die Fertigkeit zeigt, wie man das neue SwiftUI-Instrument verwendet, um Engpässe zu lokalisieren, die Ursachen-Wirkungs-Graphen zur Analyse des Datenflusses nutzt und Optimierungsmuster wie das Auslagern teurer Berechnungen (z. B. Formatierer-Erstellung) in Modelle oder Caching-Strukturen anwendet. Sie deckt zudem automatische Verbesserungen in iOS 26 ab, wie bis zu 6x schnelleres Laden von Listen und reduziertes Ruckeln beim Scrollen durch verbesserte Frame-Planung. Die Fertigkeit richtet sich an SwiftUI-Entwickler, die mit Xcode 26 und Instruments arbeiten, und bietet Entscheidungsbäume zur Priorisierung von Optimierungen sowie Anleitungen für typische Szenarien wie große Listen, verschachtelte ScrollViews und komplexe View-Hierarchien.

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

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

SwiftUI-Leistungsoptimierung

Wann Sie diese Fertigkeit nutzen sollten

Verwenden, wenn:

  • Die App sich weniger reaktionsschnell anfühlt (Ruckler, Hänger, verzögertes Scrollen)
  • Animationen während der Ausführung pausieren oder springen
  • Die Scroll-Leistung schlecht ist
  • Das Profiling zeigt, dass SwiftUI der Flaschenhals ist
  • View-Bodies zu lange für die Ausführung benötigen
  • Views häufiger aktualisiert werden als nötig
  • Sie die Ursache-Wirkung von SwiftUI-Updates verstehen müssen

Beispiel-Prompts

Dies sind reale Fragen von Entwicklern, die diese Fertigkeit zu beantworten entwickelt wurde:

1. "Meine App hat ruckelndes Scrollen und stotternde Animationen. Wie finde ich heraus, ob SwiftUI die Ursache ist?"

→ Die Fertigkeit zeigt, wie man das neue SwiftUI-Instrument in Instruments 26 verwendet, um zu identifizieren, ob SwiftUI im Vergleich zu anderen Ebenen der Flaschenhals ist.

2. "Ich verwende das neue SwiftUI-Instrument und sehe orange/rote Balken, die lange Aktualisierungen anzeigen. Woher weiß ich, was sie verursacht?"

→ Die Fertigkeit behandelt die Ursache-Wirkungs-Graphen-Muster, die den Datenfluss durch Ihre App zeigen und welche Zustandsänderungen teure Aktualisierungen auslösen.

3. "Einige Views aktualisieren sich viel zu oft, obwohl sich ihre Daten nicht geändert haben. Wie finde ich heraus, welche Views das Problem sind?"

→ Die Fertigkeit demonstriert die Erkennung unnötiger Aktualisierungen und die Fehlerbehebung bei der Identität mit der visuellen Zeitleiste.

4. "Ich habe große Datenstrukturen und komplexe View-Hierarchien. Wie optimiere ich sie für die SwiftUI-Leistung?"

→ Die Fertigkeit behandelt Leistungsmuster: Aufbrechen von View-Hierarchien, Minimieren der Body-Komplexität und Verwenden der Optimierungs-Checkliste mit @Sendable.

5. "Wir haben eine Leistungsdeadline und ich muss verstehen, was in SwiftUI langsam ist. Was sind die kritischen Metriken?"

→ Die Fertigkeit bietet den Entscheidungsbaum zur Priorisierung von Optimierungen und versteht Druckszenarien mit professioneller Anleitung für Abwägungen.


Überblick

Kernprinzip: Stellen Sie sicher, dass sich Ihre View-Bodies schnell und nur bei Bedarf aktualisieren, um eine großartige SwiftUI-Leistung zu erzielen.

NEU in WWDC 2025: Das SwiftUI-Instrument der nächsten Generation in Instruments 26 bietet umfassende Leistungsanalyse mit:

  • Visueller Zeitleiste langer Aktualisierungen (je nach Schweregrad farblich orange/rot kodiert)
  • Ursache-Wirkungs-Graph, der den Datenfluss durch Ihre App zeigt
  • Integration mit dem Zeitprofilierer für CPU-Analyse
  • Verfolgung von Hängern und Rucklern

Wichtigste Leistungsprobleme:

  1. Lange View-Body-Updates — View-Bodies benötigen zu viel Zeit für die Ausführung
  2. Unnötige View-Updates — Views aktualisieren sich, obwohl sich die Daten nicht geändert haben

Leistungsverbesserungen im iOS 26 Framework

"Leistungsverbesserungen am Framework kommen Apps auf allen Apple-Plattformen zugute, von unserer App bis zu Ihrer." — WWDC 2025-256

SwiftUI in iOS 26 enthält große Leistungsgewinne, die allen Apps automatisch zugutekommen. Diese Verbesserungen arbeiten zusammen mit den neuen Profiling-Werkzeugen, um SwiftUI sofort schneller zu machen.

Listenleistung (macOS-Fokus)

Massive Gewinne für große Listen

  • 6x schnelleres Laden für Listen mit 100.000+ Einträgen unter macOS
  • 16x schnellere Aktualisierungen für große Listen
  • Noch größere Gewinne für noch größere Listen
  • Verbesserungen kommen allen Plattformen zugute (iOS, iPadOS, watchOS, nicht nur macOS)
List(trips) { trip in // 100k+ Einträge
    TripRow(trip: trip)
}
// iOS 26: Lädt 6x schneller, aktualisiert 16x schneller unter macOS
// Alle Plattformen profitieren von den Leistungsverbesserungen

Auswirkungen auf Ihre App

  • Große Datensätze (10k+ Einträge) zeigen spürbare Verbesserungen
  • Filter- und Sortiervorgänge werden schneller abgeschlossen
  • Echtzeitaktualisierungen von Listen reagieren schneller
  • Vorteile für Apps wie Dateibrowser, Kontaktlisten, Datentabellen

Scroll-Leistung

Reduzierte verlorene Frames bei Hochgeschwindigkeits-Scrollen

SwiftUI hat die Planung von Benutzeroberflächenaktualisierungen unter iOS und macOS verbessert. Dies verbessert die Reaktionsfähigkeit und gibt SwiftUI mehr Zeit, um sich auf bevorstehende Frames vorzubereiten. Insgesamt verringert es die Wahrscheinlichkeit, dass Ihre App einen Frame fallen lässt, während Sie schnell mit hohen Bildwiederholraten scrollen.

Wichtigste Verbesserungen

  1. Bessere Frame-Planung — SwiftUI erhält mehr Zeit, um sich auf bevorstehende Frames vorzubereiten
  2. Verbesserte Reaktionsfähigkeit — UI-Updates werden effizienter geplant
  3. Weniger verlorene Frames — Besonders beim schnellen Scrollen mit 120 Hz (ProMotion)

Wann Sie es bemerken werden

  • Scrollen durch bildlastige Inhalte
  • Geräte mit hohen Bildwiederholraten (iPhone Pro, iPad Pro mit ProMotion)
  • Komplexe Listenzeilen mit mehreren Views

Verschachtelte ScrollViews mit Lazy Stacks

Fotokarussells und Achsen-Scrollen werden jetzt richtig optimiert

ScrollView(.horizontal) {
    LazyHStack {
        ForEach(photoSets) { photoSet in
            ScrollView(.vertical) {
                LazyVStack {
                    ForEach(photoSet.photos) { photo in
                        PhotoView(photo: photo)
                    }
                }
            }
        }
    }
}
// iOS 26: Verschachtelte ScrollViews verzögern jetzt das Laden mit Lazy Stacks richtig
// Ideal für Fotokarussells, Netflix-ähnliche Layouts, mehrdimensionale Inhalte

Vor iOS 26 Verschachtelte ScrollViews verzögerten das Laden von Lazy Stack-Inhalten nicht richtig, sodass alle verschachtelten Inhalte sofort geladen wurden.

Nach iOS 26 Lazy Stacks in verschachtelten ScrollViews verzögern jetzt das Laden, bis der Inhalt kurz vor dem Erscheinen ist, was dem Verhalten von einstufigen ScrollViews entspricht.

Anwendungsfälle

  • Fotogalerien mit horizontalem/vertikalem Scrollen
  • Netflix-ähnliche Kategorienzeilen
  • Mehrdimensionale Datenbrowser
  • Bilderkarussells mit vertikalem Detail-Scrollen

Erweiterungen des SwiftUI-Leistungsinstruments

Neue Spuren in Instruments 26

Das SwiftUI-Instrument enthält jetzt dedizierte Spuren für:

  1. Lange View-Body-Updates — Identifizieren teurer Body-Berechnungen
  2. Plattform-View-Updates — Verfolgen der UIKit/AppKit-Bridging-Leistung (Lange Representable-Updates)
  3. Andere lange Updates — Alle anderen Arten langer SwiftUI-Arbeit

Diese Spuren werden im nächsten Abschnitt ausführlich behandelt.

Zusammenfassung der Leistungsverbesserungen

Automatische Gewinne (nur Neukompilierung)

  • ✅ 6x schnelleres Laden von Listen (100k+ Einträge, macOS)
  • ✅ 16x schnellere Listenaktualisierungen (macOS)
  • ✅ Reduzierte verlorene Frames beim Scrollen
  • ✅ Verbesserte Frame-Planung unter iOS/macOS
  • ✅ Optimierung des verzögerten Ladens bei verschachtelten ScrollViews

Keine Code-Änderungen erforderlich — Bauen Sie mit dem iOS 26 SDK neu, um diese Verbesserungen zu erhalten.

Querverweis SwiftUI 26 Funktionen (swiftui-26-ref skill) — Umfassender Leitfaden zu allen iOS 26 SwiftUI-Änderungen


Das SwiftUI-Instrument (Instruments 26)

Erste Schritte

Voraussetzungen:

  • Xcode 26 installieren
  • Geräte auf die neuesten OS-Versionen aktualisieren (Unterstützung für die Aufzeichnung von SwiftUI-Traces)
  • App im Release-Modus für genaues Profiling erstellen

Starten:

  1. Projekt in Xcode öffnen
  2. Befehl-I drücken, um zu profilieren
  3. SwiftUI-Vorlage aus der Vorlagenauswahl wählen
  4. Auf Aufnahmetaste klicken

Vorlageninhalt

Die SwiftUI-Vorlage enthält drei Instrumente:

  1. SwiftUI-Instrument (NEU) — Identifiziert Leistungsprobleme im SwiftUI-Code
  2. Zeitprofilierer — Zeigt CPU-Arbeitsproben im Zeitverlauf
  3. Hänger und Ruckler — Verfolgt die App-Reaktionsfähigkeit

Spuren des SwiftUI-Instruments

Spur 1: Aktualisierungsgruppen

  • Zeigt, wann SwiftUI aktiv arbeitet
  • Leer bei CPU-Spitzen? → Problem liegt wahrscheinlich außerhalb von SwiftUI

Spur 2: Lange View-Body-Updates

  • Hebt hervor, wenn die body-Eigenschaft zu lange braucht
  • Häufigstes Leistungsproblem — hier beginnen

Spur 3: Lange Representable-Updates

  • Identifiziert langsame UIViewRepresentable/NSViewRepresentable-Updates
  • Leistung der UIKit/AppKit-Integration

Spur 4: Andere lange Updates

  • Alle anderen Arten langer SwiftUI-Arbeit

Farbkodierungssystem

Aktualisierungen werden je nach Wahrscheinlichkeit, Ruckler zu verursachen, in orange und rot angezeigt:

  • Rot — Sehr wahrscheinlich, zu einem Ruckler/Hänger beizutragen (zuerst untersuchen)
  • Orange — Mäßig wahrscheinlich, Probleme zu verursachen
  • Grau — Normale Aktualisierungen, nicht besorgniserregend

Hinweis: Ob Aktualisierungen tatsächlich zu Rucklern führen, hängt von den Gerätebedingungen ab, aber rote Aktualisierungen haben die höchste Priorität.


Den Render-Zyklus verstehen

Normales Frame-Rendering

Frame 1:
├─ Ereignisse behandeln (Berührungen, Tastendrücke)
├─ UI aktualisieren (View-Bodies ausführen)
│  └─ Vor der Frame-Frist abschließen ✅
├─ An das System übergeben
└─ System rendert → Auf dem Bildschirm sichtbar

Frame 2:
├─ Ereignisse behandeln
├─ UI aktualisieren
│  └─ Vor der Frame-Frist abschließen ✅
├─ An das System übergeben
└─ System rendert → Auf dem Bildschirm sichtbar

Ergebnis: Sanfte, flüssige Animationen

Frame mit Ruckler (Langer View-Body)

Frame 1:
├─ Ereignisse behandeln
├─ UI aktualisieren
│  └─ EIN VIEW-BODY IST ZU LANGSAM
│  └─ Läuft über die Frame-Frist hinaus ❌
├─ Frist verpasst
└─ Vorheriger Frame bleibt sichtbar (RUCKELER)

Frame 2: (Verzögert)
├─ Ereignisse behandeln (um 1 Frame verzögert)
├─ UI aktualisieren
├─ An das System übergeben
└─ System rendert → Endlich sichtbar

Ergebnis: Vorheriger Frame für 2+ Frames sichtbar = Animationsstottern

Frame mit Ruckler (Zu viele Aktualisierungen)

Frame 1:
├─ Ereignisse behandeln
├─ UI aktualisieren
│  ├─ Update 1 (schnell)
│  ├─ Update 2 (schnell)
│  ├─ Update 3 (schnell)
│  ├─ ... (100 weitere schnelle Updates)
│  └─ Gesamtzeit überschreitet Frist ❌
├─ Frist verpasst
└─ Vorheriger Frame bleibt sichtbar (RUCKELER)

Ergebnis: Viele kleine Updates summieren sich und verpassen die Frist

Wichtige Erkenntnis: Die Laufzeit des View-Bodies ist wichtig, da das Verpassen von Frame-Fristen Ruckler verursacht und Animationen weniger flüssig macht.

Referenz:


Problem 1: Lange View-Body-Updates

Lange Aktualisierungen identifizieren

  1. Trace aufzeichnen in Instruments mit der SwiftUI-Vorlage
  2. Auf Spur "Lange View-Body-Updates" achten — irgendwelche orangen/roten Balken?
  3. SwiftUI-Spur erweitern, um Unterspuren zu sehen
  4. Unterspur "View-Body-Updates" auswählen
  5. Auf lange Aktualisierungen filtern:
    • Detailbereich → Dropdown → "Zusammenfassung langer View-Body-Updates" wählen

Mit dem Zeitprofilierer analysieren

Workflow:

  1. Lange Aktualisierung in der Zusammenfassung langer View-Body-Updates finden
  2. Über den View-Namen schweben → Pfeil klicken → "Updates anzeigen"
  3. Rechtsklick auf lange Aktualisierung → "Inspektionsbereich festlegen und zoomen"
  4. Zur Spur des Zeitprofilierers wechseln

Was Sie sehen:

  • Aufrufstapel für Proben, die während der Ausführung des View-Bodies aufgezeichnet wurden
  • Zeit, die in jedem Frame verbracht wurde (linke Spalte)
  • Ihr View-Body, verschachtelt im tiefen SwiftUI-Aufrufstapel

Den Flaschenhals finden:

  1. Optionsklick, um den Aufrufstapel des Hauptthreads zu erweitern
  2. Befehl-F zum Suchen nach Ihrem View-Namen (z. B. "LandmarkListItemView")
  3. Teure Operationen in der Zeitspalte identifizieren

Häufige teure Operationen

Formatierer-Erstellung (Sehr teuer)

❌ FALSCH - Formatierer im View-Body erstellen:

struct LandmarkListItemView: View {
    let landmark: Landmark
    @State private var userLocation: CLLocation

    var distance: String {
        // ❌ Erstellt Formatierer jedes Mal, wenn body läuft
        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) // Ruft teure distance-Eigenschaft auf
        }
    }
}

Warum es langsam ist:

  • Formatierer sind teuer zu erstellen (Millisekunden pro Stück)
  • Werden jedes Mal erstellt, wenn der View-Body läuft
  • Läuft auf dem Hauptthread → App wartet, bevor UI-Updates fortgesetzt werden
  • Mehrere Views → Zeit summiert sich schnell auf

✅ RICHTIG - Formatierer zentral cachen:

@Observable
class LocationFinder {
    private let formatter: MeasurementFormatter
    private let landmarks: [Landmark]
    private var distanceCache: [Landmark.ID: String] = [:]

    init(landmarks: [Landmark]) {
        self.landmarks = landmarks

        // Formatierer EINMAL während der Initialisierung erstellen
        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] ?? "Unbekannt"
    }
}

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)) // ✅ Schneller Lookup
        }
    }
}

Vorteile:

  • Formatierer werden einmal erstellt, für alle Landmarken wiederverwendet
  • Zeichenfolgen werden bei Standortänderung vorberechnet
  • View-Body liest nur den zwischengespeicherten Wert (sofort)
  • Lange View-Body-Updates werden eliminiert

Andere teure Operationen

Komplexe Berechnungen:

// ❌ Nicht im View-Body berechnen
var body: some View {
    let result = expensiveAlgorithm(data) // Komplexe Mathematik, Sortierung usw.
    Text("\(result)")
}

// ✅ Im Modell berechnen, Ergebnis cachen
@Observable
class ViewModel {
    private(set) var result: Int = 0

    func updateData(_ data: [Int]) {
        result = expensiveAlgorithm(data) // Einmal berechnen
    }
}

Netzwerk-/Datei-I/O:

// ❌ NIEMALS I/O im View-Body durchführen
var body: some View {
    let data = try? Data(contentsOf: fileURL) // ❌ Synchroner I/O
    // ...
}

// ✅ Asynchron laden

…

[gekürzt für die Übersetzung]

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

Verwandte Skills