Communitygithub.com

ComeOnOliver/skillshub

Verwenden bei der Implementierung von SwiftUI-Animationen, dem Verständnis von VectorArithmetic, der Verwendung des @Animatable-Makros, Zoom-Übergängen, UIKit/AppKit-Animationsbrücken, der Wahl zwischen Spring- und Timingkurven-Animationen oder dem Debuggen von Animationsverhalten – umfassende Animationsreferenz von iOS 13 bis iOS 26.

Was ist skillshub?

Dieses Skill bietet eine umfassende Referenz zu SwiftUI-Animationen von den Grundlagen bis zu fortgeschrittenen Techniken und deckt iOS 13 bis iOS 26 ab. Es erklärt das Kernprinzip der Animation als mathematische Interpolation über die Zeit, ermöglicht durch das VectorArithmetic-Protokoll, und zeigt auf, wie animierbare Daten wie CGFloat, CGPoint und CGRect funktionieren. Der Skill behandelt das Animatable-Protokoll und das neue @Animatable-Makro (iOS 26+), das den Boilerplate-Code für benutzerdefinierte Animationen drastisch reduziert, indem es automatisch die animierbaren Eigenschaften einer View ableitet. Darüber hinaus werden verschiedene Animationstypen wie Timingkurven- und Spring-Animationen, das Transaktionssystem mit withAnimation und dem animation()-Modifier, sowie fortgeschrittene Themen wie benutzerdefinierte Animationen und das CustomAnimation-Protokoll detailliert erläutert. Der Skill ist nützlich für Entwickler, die SwiftUI-Animationen implementieren oder debuggen und dabei die neuesten iOS-Funktionen nutzen möchten.

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

In Ihrer bevorzugten KI fragen

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

Dokumentation

SwiftUI-Animation

Überblick

Umfassender Leitfaden zum Animationssystem von SwiftUI, von grundlegenden Konzepten bis zu fortgeschrittenen Techniken. Dieser Skill behandelt das Animatable-Protokoll, das @Animatable-Makro (iOS 26), Animationstypen und das Transaktionssystem.

Kernprinzip Animation in SwiftUI ist mathematische Interpolation über die Zeit, angetrieben durch das VectorArithmetic-Protokoll. Dieses Verständnis bildet die Grundlage für die volle Leistungsfähigkeit des deklarativen Animationssystems von SwiftUI.

Systemanforderungen

  • iOS 13+: Animatable-Protokoll, Timing-/Spring-Animationen
  • iOS 17+: Standard-Spring-Animationen, bereichsbezogene Animationen, PhaseAnimator, KeyframeAnimator
  • iOS 18+: Zoom-Übergänge, UIKit/AppKit-Animationsbrücken
  • iOS 26+: @Animatable-Makro

Teil 1: Animation verstehen

Was ist Interpolation

Animation ist der Prozess der Erzeugung von Zwischenwerten zwischen einem Start- und einem Endzustand.

Beispiel: Opazitätsanimation

.opacity(0) → .opacity(1)

Während diese Animation läuft, berechnet SwiftUI Zwischenwerte:

0.0 → 0.02 → 0.05 → 0.1 → 0.25 → 0.4 → 0.6 → 0.8 → 1.0

Wie Werte verteilt werden

  • Bestimmt durch die Timingkurve oder Geschwindigkeitsfunktion der Animation
  • Spring-Animationen verwenden eine physikalische Simulation
  • Timingkurven verwenden Bézier-Kurven
  • Jeder Animationstyp berechnet Werte unterschiedlich

VectorArithmetic-Protokoll

SwiftUI erfordert, dass animierte Daten dem VectorArithmetic-Protokoll entsprechen – das Subtraktion, Skalierung, Addition und einen Nullwert bereitstellt. Dies ermöglicht SwiftUI, zwischen zwei beliebigen Werten zu interpolieren.

Eingebaute konforme Typen: CGFloat, Double, Float, Angle (1D), CGPoint, CGSize (2D), CGRect (4D).

Wichtige Erkenntnis Vektorarithmetik abstrahiert über die Dimensionalität. SwiftUI animiert alle diese Typen mit einer einzigen generischen Implementierung.

Warum Int nicht animiert werden kann

Int entspricht nicht dem VectorArithmetic-Protokoll – es gibt keine fraktionalen Zwischenwerte zwischen 3 und 4. SwiftUI setzt den Wert einfach direkt.

Lösung: Verwende Float/Double und zeige sie als Int an:

@State private var count: Float = 0
// ...
Text("\(Int(count))").animation(.spring, value: count)

Modellwert vs. Darstellungswert

Animierbare Attribute haben konzeptionell zwei Werte:

Modellwert

  • Der Zielwert, der von Ihrem Code gesetzt wird
  • Wird sofort aktualisiert, wenn sich der Zustand ändert
  • Das, was Sie im body Ihrer View schreiben

Darstellungswert

  • Der aktuell interpolierte Wert, der gerendert wird
  • Wird während der Animation Bild für Bild aktualisiert
  • Das, was der Benutzer tatsächlich sieht

Beispiel

.scaleEffect(selected ? 1.5 : 1.0)

Wenn selected true wird:

  • Modellwert: Wird sofort zu 1.5
  • Darstellungswert: Interpoliert 1.0 → 1.1 → 1.2 → 1.3 → 1.4 → 1.5 über die Zeit

Teil 2: Animatable-Protokoll

Überblick

Das Animatable-Protokoll ermöglicht es Views, ihre Eigenschaften zu animieren, indem es definiert, welche Daten interpoliert werden sollen.

protocol Animatable {
    associatedtype AnimatableData: VectorArithmetic

    var animatableData: AnimatableData { get set }
}

SwiftUI erstellt ein animierbares Attribut für jede View, die diesem Protokoll entspricht.

Integrierte animierbare Views

Viele SwiftUI-Modifier entsprechen dem Animatable-Protokoll:

Visuelle Effekte

  • .scaleEffect() — Animiert die Skalierungstransformation
  • .rotationEffect() — Animiert die Rotation
  • .offset() — Animiert den Positionsversatz
  • .opacity() — Animiert die Transparenz
  • .blur() — Animiert den Unschärferadius
  • .shadow() — Animiert Schatteneigenschaften

Alle Shape-Typen

  • Circle, Rectangle, RoundedRectangle
  • Capsule, Ellipse, Path
  • Benutzerdefinierte Shape-Implementierungen

AnimatablePair für mehrdimensionale Daten

Verwende AnimatablePair, um Vektoren zu kombinieren, wenn mehrere Eigenschaften animiert werden. Beispielsweise kombiniert scaleEffect CGSize (2D) und UnitPoint (2D) zu einem 4D-Vektor über AnimatablePair<CGSize.AnimatableData, UnitPoint.AnimatableData>. Greife auf Komponenten über .first und .second zu. Das @Animatable-Makro (iOS 26+) eliminiert diesen Boilerplate-Code vollständig.

Benutzerdefinierte Animatable-Konformität

Wann verwenden

  • Animieren eines benutzerdefinierten Layouts (z. B. RadialLayout)
  • Animieren von benutzerdefiniertem Zeichencode
  • Animieren von Eigenschaften, die Shape-Pfade beeinflussen

Beispiel: Animierte Zahlenansicht

struct AnimatableNumberView: View, Animatable {
    var number: Double

    var animatableData: Double {
        get { number }
        set { number = newValue }
    }

    var body: some View {
        Text("\(Int(number))").font(.largeTitle)
    }
}

// Verwendung
AnimatableNumberView(number: value).animation(.spring, value: value)

Wie es funktioniert

  1. number ändert sich von 0 auf 100
  2. SwiftUI ruft body für jedes Bild der Animation auf
  3. Jedes Bild erhält einen neuen number-Wert: 0 → 5 → 15 → 30 → 55 → 80 → 100
  4. Der Text wird aktualisiert, um die interpolierte Ganzzahl anzuzeigen

Leistungswarnung

Benutzerdefinierte Animatable-Konformität ist teuer — SwiftUI ruft body für jedes Bild im Hauptthread auf. Eingebaute Effekte (.scaleEffect(), .opacity()) laufen nebenläufig zum Hauptthread und rufen body nicht auf. Verwende benutzerdefinierte Konformität nur, wenn eingebaute Modifier den Effekt nicht erzielen können (z. B. beim Animieren eines benutzerdefinierten Layout, das Unterviews pro Bild neu positioniert).


Teil 3: @Animatable-Makro (iOS 26+)

Überblick

Das @Animatable-Makro eliminiert den Boilerplate-Code der manuellen Konformität zum Animatable-Protokoll.

Vor iOS 26 musstest du:

  1. Manuell Animatable konform sein
  2. animatableData-Getter und -Setter schreiben
  3. AnimatablePair für mehrere Eigenschaften verwenden
  4. Nicht-animierbare Eigenschaften manuell ausschließen

Ab iOS 26+ fügst du einfach @Animatable hinzu:

@MainActor
@Animatable
struct MyView: View {
    var scale: CGFloat
    var opacity: Double

    var body: some View {
        // ...
    }
}

Das Makro automatisiert:

  • Erzeugt Animatable-Konformität
  • Untersucht alle gespeicherten Eigenschaften
  • Erstellt animatableData aus VectorArithmetic-konformen Eigenschaften
  • Behandelt mehrdimensionale Daten mit AnimatablePair

Vorher/Nachher-Vergleich

Vor dem @Animatable-Makro

struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double
    var drawingDirection: Bool // Soll nicht animiert werden

    // Mühsame manuelle animatableData-Deklaration
    var animatableData: AnimatablePair<AnimatablePair<CGFloat, CGFloat>,
                        AnimatablePair<Double, AnimatablePair<CGFloat, CGFloat>>> {
        get {
            AnimatablePair(
                AnimatablePair(startPoint.x, startPoint.y),
                AnimatablePair(elevation, AnimatablePair(endPoint.x, endPoint.y))
            )
        }
        set {
            startPoint = CGPoint(x: newValue.first.first, y: newValue.first.second)
            elevation = newValue.second.first
            endPoint = CGPoint(x: newValue.second.second.first, y: newValue.second.second.second)
        }
    }

    func path(in rect: CGRect) -> Path {
        // Zeichencode
    }
}

Nach dem @Animatable-Makro

@Animatable
struct HikingRouteShape: Shape {
    var startPoint: CGPoint
    var endPoint: CGPoint
    var elevation: Double

    @AnimatableIgnored
    var drawingDirection: Bool // Von der Animation ausgeschlossen

    func path(in rect: CGRect) -> Path {
        // Zeichencode
    }
}

Codezeilen: 20 → 12 (40% Reduktion)

@AnimatableIgnored

Verwende @AnimatableIgnored, um Eigenschaften von der Animation auszuschließen.

Wann verwenden

  • Debug-Werte — Flags nur für die Entwicklung
  • IDs — Bezeichner, die nicht animiert werden sollen
  • Zeitstempel — Wann die View erstellt/aktualisiert wurde
  • Interner Zustand — Nicht-visuelle Buchhaltung
  • Nicht-VectorArithmetic-Typen — Farben, Zeichenketten, Boolesche Werte

Beispiel

@MainActor
@Animatable
struct ProgressView: View {
    var progress: Double // Animiert
    var totalItems: Int // Animiert (wenn Float, nicht wenn Int)

    @AnimatableIgnored
    var title: String // Nicht animiert

    @AnimatableIgnored
    var startTime: Date // Nicht animiert

    @AnimatableIgnored
    var debugEnabled: Bool // Nicht animiert

    var body: some View {
        VStack {
            Text(title)
            ProgressBar(value: progress)
            if debugEnabled {
                Text("Gestartet: \(startTime.formatted())")
            }
        }
    }
}

Praxisnaher Anwendungsfall

@Animatable funktioniert für jede numerische Anzeige – Aktienkurse, Herzfrequenz, Punktzahlen, Timer, Fortschrittsbalken:

@MainActor
@Animatable
struct AnimatedValueView: View {
    var value: Double
    var changePercent: Double

    @AnimatableIgnored
    var label: String

    var body: some View {
        VStack(alignment: .trailing) {
            Text("\(value, format: .number.precision(.fractionLength(2)))")
                .font(.title)
            Text("\(changePercent > 0 ? "+" : "")\(changePercent, format: .percent)")
                .foregroundStyle(changePercent > 0 ? .green : .red)
        }
    }
}

// Verwendung
AnimatedValueView(value: currentPrice, changePercent: 0.025, label: "Preis")
    .animation(.spring(duration: 0.8), value: currentPrice)

Teil 4: Animationstypen

Timingkurven-Animationen

Timingkurven-Animationen verwenden Bézier-Kurven, um die Geschwindigkeit der Animation über die Zeit zu steuern.

Integrierte Voreinstellungen

.animation(.linear)          // Konstante Geschwindigkeit
.animation(.easeIn)          // Startet langsam, endet schnell
.animation(.easeOut)         // Startet schnell, endet langsam
.animation(.easeInOut)       // Langsamer Start und Ende, schnelle Mitte

Benutzerdefinierte Timingkurven

let customCurve = UnitCurve(
    startControlPoint: CGPoint(x: 0.2, y: 0),
    endControlPoint: CGPoint(x: 0.8, y: 1)
)

.animation(.timingCurve(customCurve, duration: 0.5))

Dauer

Alle Timingkurven-Animationen akzeptieren eine optionale Dauer:

.animation(.easeInOut(duration: 0.3))
.animation(.linear(duration: 1.0))

Standard: 0,35 Sekunden

Spring-Animationen

Spring-Animationen verwenden eine physikalische Simulation, um natürliche, organische Bewegungen zu erzeugen.

Integrierte Voreinstellungen

.animation(.smooth)     // Kein Hüpfen (Standard seit iOS 17)
.animation(.snappy)     // Kleine Menge an Hüpfen
.animation(.bouncy)     // Größere Menge an Hüpfen

Benutzerdefinierte Springs

.animation(.spring(duration: 0.6, bounce: 0.3))

Parameter

  • duration — Wahrgenommene Animationsdauer
  • bounce — Menge an Hüpfen (0 = kein Hüpfen, 1 = sehr hüpfend)

Viel intuitiver als traditionelle Spring-Parameter (Masse, Steifigkeit, Dämpfung).

Höherwertige Animationen

Modifiziere Basisanimationen, um komplexe Effekte zu erzeugen.

Verzögerung

.animation(.spring.delay(0.5))

Wartet 0,5 Sekunden, bevor die Animation startet.

Wiederholung

.animation(.easeInOut.repeatCount(3, autoreverses: true))
.animation(.linear.repeatForever(autoreverses: false))

Wiederholt die Animation mehrmals oder unendlich oft.

Geschwindigkeit

.animation(.spring.speed(2.0))  // 2x schneller
.animation(.spring.speed(0.5))  // 2x langsamer

Multipliziert die Animationsgeschwindigkeit.

Änderungen der Standardanimation (iOS 17+)

Vor iOS 17

withAnimation {
    // Verwendete standardmäßig Timingkurve
}

iOS 17+

withAnimation {
    // Verwendet standardmäßig .smooth spring
}

Warum die Änderung: Spring-Animationen fühlen sich natürlicher an und bewahren die Geschwindigkeit, wenn sie unterbrochen werden.

Empfehlung: Setze auf Springs. Sie lassen deine UI reaktionsschneller und ausgefeilter wirken.


Teil 5: Transaktionssystem

withAnimation

Der gebräuchlichste Weg, eine Animation auszulösen.

Button("Vergrößern") {
    withAnimation(.spring) {
        scale = 1.5
    }
}

Wie es funktioniert

  1. withAnimation öffnet eine Transaktion
  2. Setzt die Animation im Transaktionswörterbuch
  3. Führt den Closure aus (Statusänderungen)
  4. Die Transaktion propagiert die View-Hierarchie hinunter
  5. Animierbare Attribute prüfen auf Animation und interpolieren

Explizite Animation

withAnimation(.spring(duration: 0.6, bounce: 0.4)) {
    isExpanded.toggle()
}

Keine Animation

withAnimation(nil) {
    // Änderungen erfolgen sofort, keine Animation
    resetState()
}

animation()-View-Modifier

Wende Animationen auf bestimmte Werte innerhalb einer View an.

Grundlegende Verwendung

Circle()
    .fill(isActive ? .blue : .gray)
    .animation(.spring, value: isActive)

Wie es funktioniert: Die Animation wird nur ausgelöst, wenn sich isActive ändert. Andere Statusänderungen lösen diese Animation nicht aus.

Mehrere Animationen auf derselben View

Circle()
    .scaleEffect(scale)
    .animation(.bouncy, value: scale)
    .opacity(opacity)
    .animation(.easeInOut, value: opacity)

Unterschiedliche Animationen für unterschiedliche Eigenschaften.

Bereichsbezogene Animationen (iOS 17+)

Beschränke Animationen eng auf bestimmte animierbare Attribute.

Problem mit dem alten Ansatz

struct AvatarView: View {
    var selected: Bool

    var body: some View {
        Image("avatar")
            .scaleEffect(selected ? 1.5 : 1.0)
            .animation(.spring, value: selected)
            // ⚠️ Wenn sich das Bild auch ändert, wenn selected
            //    geändert wird, wird der Bildübergang ebenfalls
            //    animiert (versehentlich)
    }
}

Lösung: Bereichsbezogene Animation

struct AvatarView: View {
    var selected: Bool

    var body: some View {
        Image("avatar")
            .animation(.spring, value: selected) {
                $0.scaleEffect(selected ? 1.5 : 1.0)
            }
            // ✅ Nur scaleEffect wird animiert, Bildübergang nicht
    }
}

Wie es funktioniert

  • Die Animation gilt nur für Attribute im Closure
  • Andere Attribute sind nicht betroffen
  • Verhindert versehentliche Animationen

Benutzerdefinierte Transaktionsschlüssel

Definiere benutzerdefinierte TransactionKey-Typen, um Kontext durch das Transaktionssystem zu propagieren. Verwende withTransaction, um Werte zu setzen, und den .transaction-Modifier, um sie zu lesen. Dies ermöglicht es, unterschiedliche Animationen basierend darauf anzuwenden, wie eine Statusänderung ausgelöst wurde (Tippen vs. programmatisch).


Teil 6: Fortgeschrittene Themen

CustomAnimation-Protokoll

Implementiere benutzerdefinierte Animationsalgorithmen, indem du dem CustomAnimation-Protokoll entspricht. Verwende es, um einzigartige zeitliche Abläufe zu erstellen, die über integrierte Timingkurven und Springs hinausgehen. Dies ist nützlich für Spezialeffekte wie Gummiband-Effekte, benutzerdefinierte Federn oder jede andere mathematische Funktion, die über die Zeit interpoliert. Sieh dir die SwiftUI-Dokumentation für Details zur Konformität an.

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