Communitygithub.com

TheMystic07/OpenWalc

Bewegungsdesign und Animationen für Benutzeroberflächen. Verwende dies beim Erstellen von Mikrointeraktionen, Seitenübergängen, Ladezuständen oder UI-Animationen auf Web- und Mobilplattformen.

Was ist OpenWalc?

Diese Skill, 'UI Animation & Motion Design', ist ein umfassender Leitfaden für die Erstellung zielgerichteter, performanter Animationen in Benutzeroberflächen. Sie ist für Entwickler und Designer gedacht, die mit Frameworks wie React, GSAP oder reinem CSS arbeiten, um Mikrointeraktionen, Seitenübergänge und Ladezustände zu implementieren. Die Skill behandelt grundlegende Animationsprinzipien (angewendet auf UI), Timing-Richtlinien, Easing-Funktionen, GPU-beschleunigte Performance-Optimierung, Techniken wie FLIP und Keyframe-Animationen sowie die Integration in Designsysteme. Ein besonderer Schwerpunkt liegt auf Barrierefreiheit (prefers-reduced-motion) und plattformspezifischen Konventionen für iOS, Android und das Web. Die Skill ist plattformunabhängig und bietet Codebeispiele in CSS, JavaScript, Framer Motion und GSAP.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/TheMystic07/OpenWalc/tree/HEAD/.agent/skills/ui-animation

In Ihrer bevorzugten KI fragen

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

Dokumentation

UI-Animation & Bewegungsdesign

Umfassender Leitfaden für die Erstellung zielgerichteter, performanter Animationen in Benutzeroberflächen.

Animationsprinzipien

Die 12 Prinzipien der Animation (angewendet auf UI)

PrinzipUI-Anwendung
TimingDauer spiegelt Bedeutung/Entfernung wider
EasingNatürliche Beschleunigung/Verlangsamung
AntizipationVisuelle Vorbereitung auf eine Aktion
NachlaufSchwung setzt sich nach dem Stopp fort
NebenaktionUnterstützende Elemente reagieren
InszenierungAufmerksamkeit auf Schlüsselelement lenken
Stauchen & StreckenHüpfende, verspielte Interaktionen
ÜbertreibungWichtiges Feedback betonen
BogenNatürliche, geschwungene Bewegungspfade
ÜberlappungElemente bewegen sich mit unterschiedlicher Geschwindigkeit
Konsistente ZeichnungEinheitlichen 3D-Raum beibehalten
AnziehungskraftAnsprechende, entzückende Bewegung

Warum animieren?

FUNKTIONALE ZWECKE:
✓ Aufmerksamkeit auf wichtige Änderungen lenken
✓ Beziehungen zwischen Elementen zeigen
✓ Feedback für Aktionen geben
✓ Systemstatus kommunizieren
✓ Kognitive Belastung verringern
✓ Räumliche Orientierung schaffen

NICHT FÜR:
✗ Reine Dekoration
✗ Fähigkeiten zur Schau stellen
✗ Dinge "modern" wirken lassen
✗ Vom Inhalt ablenken

Timing & Dauer

Richtlinien zur Dauer

SOFORT (0-100ms):
└─→ Button-Zustandsänderungen
└─→ Kippschalter
└─→ Mikro-Feedback

SCHNELL (100-200ms):
└─→ Hover-Effekte
└─→ Einfache Einblendungen
└─→ Kleine Bewegungen

STANDARD (200-300ms):
└─→ Die meisten UI-Übergänge
└─→ Modal öffnen/schließen
└─→ Dropdown-Menüs

LANGSAM (300-500ms):
└─→ Komplexe Übergänge
└─→ Seitenübergänge
└─→ Große Elementbewegungen

BEDÄCHTIG (500ms+):
└─→ Hero-Animationen
└─→ Skeleton-Ladezustände
└─→ Onboarding-Sequenzen

Distanzbasiertes Timing

Regel: Längere Distanz = Längere Dauer

Klein (< 100px):   150-200ms
Mittel (100-300px): 200-300ms
Groß (300-500px):  300-400ms
Vollbild:          400-500ms

Formel:
dauer = basisZeit + (distanz × faktor)

Easing-Funktionen

Standard-Easings

LINEAR
├────────────────────────────┤
Konstante Geschwindigkeit. Selten natürlich.
Verwendung: Fortschrittsbalken, Uhrzeiger

EASE-OUT (Verlangsamung)
├═══════════────────────────┤
Schneller Start, langsames Ende.
Verwendung: Elemente, die in den Bildschirm kommen

EASE-IN (Beschleunigung)
├────────────────═══════════┤
Langsamer Start, schnelles Ende.
Verwendung: Elemente, die den Bildschirm verlassen

EASE-IN-OUT (S-Kurve)
├────═══════════════────────┤
Langsamer Start und Ende, schnelle Mitte.
Verwendung: Bildschirminterne Übergänge

EASE-OUT-BACK (Überschwingen)
├═══════════────────────╗───┤
Überschwingt, pendelt sich ein.
Verwendung: Verspielte Eingänge, Bounces

CSS-Easing-Werte

/* Integrierte Schlüsselwörter */
linear: cubic-bezier(0, 0, 1, 1)
ease: cubic-bezier(0.25, 0.1, 0.25, 1)
ease-in: cubic-bezier(0.42, 0, 1, 1)
ease-out: cubic-bezier(0, 0, 0.58, 1)
ease-in-out: cubic-bezier(0.42, 0, 0.58, 1)

/* Material Design Standard */
standard: cubic-bezier(0.4, 0, 0.2, 1)
decelerate: cubic-bezier(0, 0, 0.2, 1)
accelerate: cubic-bezier(0.4, 0, 1, 1)

/* Benutzerdefiniert: Schnell */
snappy: cubic-bezier(0.5, 0, 0, 1)

/* Benutzerdefiniert: Hüpfend */
bouncy: cubic-bezier(0.68, -0.55, 0.27, 1.55)

/* Federähnlich (JS-Bibliotheken verwenden) */
spring: { stiffness: 300, damping: 20 }

Wann welches verwenden

SzenarioEasingWarum
Element tritt einease-outKommt energisch an, beruhigt sich
Element tritt ausease-inSammelt Schwung zum Verlassen
Bildschirminterne Änderungease-in-outSanfter Zustandswechsel
Aufmerksamkeit erregenbounce/springVerspielt, auffällig
Hintergrund/dezentease-outUnaufdringlich

Animationsmuster

Mikrointeraktionen

BUTTON-ZUSTÄNDE:
┌─────────────────────────────────────────┐
│ Ruhe → Hover: scale(1.02), 100ms        │
│ Hover → Aktiv: scale(0.98), 50ms        │
│ Aktiv → Ruhe: scale(1), 150ms ease-out  │
└─────────────────────────────────────────┘

KIPPSCHALTER:
┌─────────────────────────────────────────┐
│ Daumen: translateX, 200ms ease-out       │
│ Spur: background-color, 200ms            │
│ Zustand: leichtes Hüpfen am Ende         │
└─────────────────────────────────────────┘

CHECKBOX:
┌─────────────────────────────────────────┐
│ Häkchen: stroke-dashoffset-Animation     │
│ Hintergrund: Skalierung von der Mitte, 150ms │
│ Welle: expandierender Kreis, 300ms       │
└─────────────────────────────────────────┘

Ladezustände

SKELETON-BILDSCHIRME:
┌──────────────────────────┐
│ ▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░░░  │ Schimmereffekt
│ ▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░  │ Linearer Verlauf
│ ▓▓▓▓▓▓░░░░░░░░░░░░░░░░  │ Bewegung von links nach rechts
└──────────────────────────┘

CSS:
background: linear-gradient(
  90deg,
  #f0f0f0 25%,
  #e0e0e0 50%,
  #f0f0f0 75%
);
background-size: 200% 100%;
animation: shimmer 1.5s infinite;

SPINNER:
- Dauer: 1-2 Sekunden pro Umdrehung
- Easing: linear (gleichmäßige Bewegung)
- Stil: Passend zur Markenidentität

Seitenübergänge

ÜBERBLENDUNG:
├──────────────────────────────────────────┤
│ Alte Seite: Deckkraft 1 → 0, 200ms       │
│ Neue Seite: Deckkraft 0 → 1, 200ms       │
│ Timing: Sequentiell oder überlappend      │
└──────────────────────────────────────────┘

SCHIEBEN:
├──────────────────────────────────────────┤
│ Richtung folgt der Navigationshierarchie │
│ Vorwärts: Nach links schieben (neu von rechts) │
│ Zurück: Nach rechts schieben (vorherige von links) │
│ Dauer: 300-400ms                         │
└──────────────────────────────────────────┘

GEMEINSAMES ELEMENT:
├──────────────────────────────────────────┤
│ Element verwandelt sich zwischen Zuständen │
│ Position, Größe, border-radius ändern sich │
│ Erzeugt Kontinuität zwischen Bildschirmen │
│ Dauer: 300-500ms                         │
└──────────────────────────────────────────┘

Listen-Animationen

GESTAFFELTER EINTRITT:
┌─ Element 1 ────────────────┐  Verzögerung: 0ms
├─ Element 2 ────────────────┤  Verzögerung: 50ms
├─ Element 3 ────────────────┤  Verzögerung: 100ms
├─ Element 4 ────────────────┤  Verzögerung: 150ms
└─ Element 5 ────────────────┘  Verzögerung: 200ms

Maximale Gesamtdauer: 500ms
Staffelung: 30-50ms pro Element
Animation: translateY + Deckkraft

NEUORDNUNG:
- FLIP-Technik verwenden
- Dauer: 200-300ms
- Easing: ease-out

Leistung

GPU-beschleunigte Eigenschaften

SCHNELL (Nur Compositor):
✓ transform: translate, scale, rotate
✓ opacity
✓ filter (mit will-change)

LANGSAM (Löst Layout/Paint aus):
✗ width, height
✗ margin, padding
✗ top, left, right, bottom
✗ border, border-radius
✗ font-size
✗ box-shadow (Neuzeichnung)

OPTIMIERUNG:
will-change: transform, opacity;
/* Sparsam verwenden! */

Leistungsrichtlinien

/* Gut: GPU-beschleunigt */
.animated-element {
  transform: translateX(0);
  transition: transform 300ms ease-out;
}
.animated-element.moved {
  transform: translateX(100px);
}

/* Schlecht: Layout-Thrashing */
.animated-element {
  left: 0;
  transition: left 300ms ease-out;
}
.animated-element.moved {
  left: 100px;
}

FLIP-Technik

// Zuerst: Anfangsposition ermitteln
const first = element.getBoundingClientRect();

// Zuletzt: Änderung anwenden, Endposition ermitteln
element.classList.add("moved");
const last = element.getBoundingClientRect();

// Umkehren: Delta berechnen, inverse Transformation anwenden
const deltaX = first.left - last.left;
const deltaY = first.top - last.top;
element.style.transform = `translate(${deltaX}px, ${deltaY}px)`;

// Abspielen: Transformation mit Übergang entfernen
requestAnimationFrame(() => {
  element.style.transition = "transform 300ms ease-out";
  element.style.transform = "";
});

CSS-Animationstechniken

Keyframe-Animation

@keyframes fadeSlideIn {
  from {
    opacity: 0;
    transform: translateY(20px);
  }
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

.element {
  animation: fadeSlideIn 300ms ease-out forwards;
}

/* Mit Schritten */
@keyframes typewriter {
  from {
    width: 0;
  }
  to {
    width: 100%;
  }
}

.typing-text {
  animation: typewriter 2s steps(20) forwards;
}

Übergang

.button {
  background: var(--primary);
  transform: scale(1);
  transition:
    background 150ms ease-out,
    transform 100ms ease-out;
}

.button:hover {
  background: var(--primary-hover);
  transform: scale(1.02);
}

.button:active {
  transform: scale(0.98);
  transition-duration: 50ms;
}

Animation-Kurzschreibweise

/* animation: name duration timing-function delay
              iteration-count direction fill-mode play-state */

animation: slideIn 300ms ease-out 100ms 1 normal forwards running;

/* Häufige Muster */
animation: spin 1s linear infinite;
animation: pulse 2s ease-in-out infinite alternate;
animation: fadeIn 300ms ease-out forwards;

JavaScript-Animation-Bibliotheken

Vergleich

BibliothekAm besten geeignet fürBundle-Größe
CSSEinfache Übergänge0kb
Web Animations APINativ, performant0kb
GSAPKomplex, präzise~60kb
Framer MotionReact-Ökosystem~50kb
anime.jsTimeline, SVG~17kb
Motion OneModern, leichtgewichtig~18kb
LottieAfter Effects Export~50kb

Framer Motion (React)

import { motion, AnimatePresence } from "framer-motion";

// Basis-Animation
<motion.div
  initial={{ opacity: 0, y: 20 }}
  animate={{ opacity: 1, y: 0 }}
  exit={{ opacity: 0, y: -20 }}
  transition={{ duration: 0.3, ease: "easeOut" }}
>
  Inhalt
</motion.div>;

// Varianten für komplexe Animationen
const containerVariants = {
  hidden: { opacity: 0 },
  visible: {
    opacity: 1,
    transition: {
      staggerChildren: 0.1,
    },
  },
};

const itemVariants = {
  hidden: { opacity: 0, y: 20 },
  visible: { opacity: 1, y: 0 },
};

<motion.ul variants={containerVariants} initial="hidden" animate="visible">
  {items.map((item) => (
    <motion.li key={item.id} variants={itemVariants}>
      {item.name}
    </motion.li>
  ))}
</motion.ul>;

GSAP

import { gsap } from "gsap";

// Basis-Tween
gsap.to(".element", {
  x: 100,
  opacity: 1,
  duration: 0.3,
  ease: "power2.out",
});

// Timeline
const tl = gsap.timeline();
tl.from(".header", { y: -100, duration: 0.5 })
  .from(".content", { opacity: 0, duration: 0.3 }, "-=0.2")
  .from(".button", { scale: 0.8, duration: 0.2 });

// ScrollTrigger
gsap.registerPlugin(ScrollTrigger);
gsap.to(".parallax", {
  y: -100,
  scrollTrigger: {
    trigger: ".section",
    start: "top center",
    end: "bottom center",
    scrub: true,
  },
});

Barrierefreiheit

Benutzereinstellungen respektieren

/* Bewegung für Nutzer reduzieren, die es bevorzugen */
@media (prefers-reduced-motion: reduce) {
  *,
  *::before,
  *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
  }
}

/* Oder einfachere Alternativen bereitstellen */
@media (prefers-reduced-motion: reduce) {
  .animated-element {
    /* Bewegung durch Deckkraft ersetzen */
    animation: none;
    transition: opacity 200ms ease;
  }
}

Sichere Animationspraktiken

VERMEIDEN bei vestibulären Störungen:
✗ Parallax-Scrolling-Effekte
✗ Zoom-/Skalierungsanimationen
✗ Sich drehende/rotierende Elemente
✗ Automatisch abspielende Animationen
✗ Blinken (>3 Mal pro Sekunde)

SICHERE Alternativen:
✓ Deckkraft-Überblendungen
✓ Farbübergänge
✓ Dezente Positionsänderungen
✓ Benutzerinitiierte Animationen

WCAG-Richtlinien

2.2.2 Pause, Stop, Ausblenden:
- Automatisch aktualisierende Inhalte können pausiert werden
- Keine Zeitlimits zum Lesen

2.3.1 Drei Blitze:
- Nichts blinkt mehr als 3x pro Sekunde

2.3.3 Animation durch Interaktionen:
- Bewegung kann deaktiviert werden
- Ausgelöste Animationen respektieren Einstellungen

Mobile Überlegungen

Touch-Feedback

/* iOS-artiges Tipp-Feedback */
.button {
  -webkit-tap-highlight-color: transparent;
  touch-action: manipulation;
}

.button:active {
  opacity: 0.7;
  transition: opacity 50ms;
}

/* Welleneffekt */
.ripple {
  position: relative;
  overflow: hidden;
}

.ripple::after {
  content: "";
  position: absolute;
  background: rgba(255, 255, 255, 0.3);
  border-radius: 50%;
  transform: scale(0);
  animation: ripple 400ms ease-out;
}

Plattform-Konventionen

PlattformAnimationsstil
iOSFederphysik, 300-500ms, dezent
AndroidMaterial Motion, 200-300ms, betont
WebVariiert, typischerweise 200-400ms

Designsystem-Integration

Animations-Tokens

:root {
  /* Dauern */
  --duration-instant: 100ms;
  --duration-fast: 150ms;
  --duration-normal: 250ms;
  --duration-slow: 400ms;
  --duration-slower: 600ms;

  /* Easings */
  --ease-default: cubic-bezier(0.4, 0, 0.2, 1);
  --ease-in: cubic-bezier(0.4, 0, 1, 1);
  --ease-out: cubic-bezier(0, 0, 0.2, 1);
  --ease-bounce: cubic-bezier(0.68, -0.55, 0.27, 1.55);

  /* Kombiniert */
  --transition-default: var(--duration-normal) var(--ease-default);
  --transition-fast: var(--duration-fast) var(--ease-out);
}

/* Verwendung */
.element {
  transition: transform var(--transition-default);
}

Best Practices

TUN:

  • Animieren mit Absicht (Feedback, Führung)
  • GPU-beschleunigte Eigenschaften verwenden
  • Dauern unter 500ms halten
  • Animation an die Markenpersönlichkeit anpassen
  • prefers-reduced-motion respektieren
  • Auf Geräten mit niedriger Leistung testen
  • Konsistentes Timing-System verwenden

NICHT TUN:

  • Nur zur Dekoration animieren
  • Benutzerinteraktion blockieren
  • Übermäßiges Hüpfen/Überschwingen verwenden
  • Auslöser für Reisekrankheit erzeugen
  • Exit-Animationen vergessen
  • Leistungskennzahlen ignorieren

Individual skills in this repo

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

Verwandte Skills