Communitygithub.com

MengTo/Skills

Erstelle erstklassige, kinematografische Web-Bewegungssysteme mit GSAP, ScrollTrigger und Lenis. Ideal für luxuriöse Redaktionsseiten, kreative Studio-Portfolios und Awwwards-inspirierte Interaktionen.

Was ist Skills?

Diese Fähigkeit (Skill) bietet ein umfassendes, modulares Bewegungssystem für das Web, das auf GSAP, ScrollTrigger und Lenis basiert. Es wurde entwickelt, um hochwertige, kinematografische Erlebnisse zu schaffen, die an den Stil von Apple oder preisgekrönten Kreativstudios erinnern. Der Skill definiert klare, subtile Bewegungs-Farbcodes (Eases, Dauern, Versätze) und stellt sofort einsatzbereite JavaScript-Funktionen und HTML-Markup-Vorlagen bereit. Dadurch lassen sich Effekte wie gestaffelte Texteinblendungen, Parallax-Scrolling, Pinned-Sections, magnetische Hover-Zustände und benutzerdefinierte Cursor mit minimalem Aufwand umsetzen. Er bevorzugt eine reduzierte, elegante Motion-Sprache – ohne hüpfende oder verspielte Animationen – und ist barrierefreundlich durch die automatische Respektierung der `prefers-reduced-motion`-Einstellung. Der Einsatz ist besonders empfehlenswert für Storytelling-Seiten oder Projekte mit hohem ästhetischen Anspruch, die ein einheitliches und professionelles Bewegungsvokabular benötigen.

Funktioniert mit~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/MengTo/Skills/tree/HEAD/agent-skills/web-design/cinematic-gsap-lenis-motion-system

In Ihrer bevorzugten KI fragen

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

Vorschau

Aus dem Skill-README

Skills preview

Dokumentation

Kinematografisches GSAP-Lenis-Bewegungssystem

Verwendung

  • Die Website benötigt eine erstklassige Motion-Sprache, nicht nur eine isolierte Animation.
  • Sanftes Scrollen, Scroll-Enthüllungen, Pinned-Szenen, Parallax, Hover-Bewegungen und Cursor-Verhalten sollen sich verbunden anfühlen.
  • Das angestrebte Gefühl ist: luxuriöses Editorial, Apple-ähnliche Raffinesse, kreatives Studio-Portfolio oder immersives, kinematografisches Storytelling.
  • Der Technologie-Stack kann GSAP, ScrollTrigger und Lenis verwenden.

Bewegungsästhetik

  • Sanft, elegant, leicht verzögert und bewusst.
  • Gestaffelte Bewegungen sollten die Lesereihenfolge leiten.
  • Geschichtete Bewegungen sollen Tiefe erzeugen, ohne die Benutzeroberfläche überladen wirken zu lassen.
  • ScrollTrigger sollte Szenen starten, wenn sie in den Viewport gelangen, nicht auf jede winzige Scrollbewegung reagieren.
  • Bevorzuge Subtilität gegenüber Intensität.

Vermeide:

  • Hüpfende, elastische, federnde oder verspielte Bewegungen.
  • Schnelle, abrupte Übergänge.
  • Große Skalensprünge.
  • Überanimierte UI-Elemente.
  • Auffällige Spiel-Effekte.

Basis-Tokens

  • Eases: power3.out, power4.out, expo.out.
  • Scroll Scrub: scrub: 0.8 bis 1.4 für kinematografische Verzögerung.
  • Enthüllungen: 0.75s bis 1.1s.
  • Hover: 0.35s bis 0.6s.
  • Cursor-Verzögerung: 0.25s bis 0.45s.
  • Text-Staffelung: Wörter 0.035s bis 0.07s, Zeilen 0.08s bis 0.14s.
  • Karten-Staffelung: 0.06s bis 0.1s.
  • Enthüllungs-Trigger: start: "top 82%".
  • Pin-Übergabe: anticipatePin: 1.

Einrichtung

Installation:

npm i gsap lenis

Einmal initialisieren, nachdem das DOM existiert. Lenis treibt seine RAF über den GSAP-Ticker an, sodass ScrollTrigger und sanftes Scrollen synchron bleiben.

import Lenis from "lenis";
import "lenis/dist/lenis.css";
import { gsap } from "gsap";
import { ScrollTrigger } from "gsap/ScrollTrigger";

gsap.registerPlugin(ScrollTrigger);
gsap.defaults({ ease: "power3.out", duration: 0.85 });

const reduceMotion = window.matchMedia("(prefers-reduced-motion: reduce)").matches;

let lenis;

if (!reduceMotion) {
  lenis = new Lenis({
    lerp: 0.08,
    smoothWheel: true,
    wheelMultiplier: 0.9,
    anchors: true,
  });

  lenis.on("scroll", ScrollTrigger.update);

  gsap.ticker.add((time) => {
    lenis.raf(time * 1000);
  });

  gsap.ticker.lagSmoothing(0);
}

window.addEventListener("load", () => {
  ScrollTrigger.refresh();
});

Markup-API

Verwende kleine Datenattribute, damit das Bewegungssystem seitenübergreifend wiederverwendet werden kann.

<h1 data-motion-text="lines">Digitale Produkte mit kinematografischer Zurückhaltung.</h1>
<p data-motion-text="words">Jede Interaktion sollte sich bewusst anfühlen.</p>

<section data-reveal-group>
  <article data-reveal="fade-up" data-reveal-item>...</article>
  <article data-reveal="fade-up" data-reveal-item>...</article>
</section>

<figure data-image-reveal data-parallax-section>
  <img data-parallax-image src="/studio.jpg" alt="">
</figure>

<a data-magnetic data-cursor-label="Entdecken" href="/work">Entdecken</a>
<div data-cursor><span data-cursor-label></span></div>

CSS-Grundlage

html.has-motion [data-motion-text],
html.has-motion [data-reveal],
html.has-motion [data-reveal-item],
html.has-motion [data-image-reveal] {
  visibility: hidden;
}

.motion-line-mask,
.motion-word-mask {
  display: inline-block;
  overflow: hidden;
  vertical-align: top;
}

.motion-line,
.motion-word {
  display: inline-block;
  will-change: transform, opacity, filter;
}

[data-image-reveal] {
  overflow: hidden;
}

[data-parallax-image] {
  display: block;
  width: 100%;
  height: 115%;
  object-fit: cover;
  will-change: transform;
}

[data-cursor] {
  position: fixed;
  left: 0;
  top: 0;
  z-index: 9999;
  pointer-events: none;
  mix-blend-mode: difference;
  transform: translate3d(-50%, -50%, 0);
  will-change: transform;
}

@media (prefers-reduced-motion: reduce), (pointer: coarse) {
  [data-cursor] {
    display: none;
  }
}

Gestaffelte Texteinblendungen

Verwende maskierte Container für erstklassigen Text. Bevorzuge manuelle Zeilenumbrüche, wenn exakte Zeilenumbrüche wichtig sind. Verwende Wort-Trennung für flexiblen, responsiven Text.

document.documentElement.classList.add("has-motion");

function splitWords(element) {
  if (element.dataset.motionSplit === "true") return;

  const text = element.textContent || "";
  const parts = text.split(/(\s+)/);

  element.textContent = "";
  element.setAttribute("aria-label", text.trim());

  let index = 0;
  parts.forEach((part) => {
    if (!part.trim()) {
      element.appendChild(document.createTextNode(part));
      return;
    }

    const mask = document.createElement("span");
    const word = document.createElement("span");

    mask.className = "motion-word-mask";
    mask.setAttribute("aria-hidden", "true");
    word.className = "motion-word";
    word.textContent = part;
    word.style.setProperty("--word-index", index);

    mask.appendChild(word);
    element.appendChild(mask);
    index += 1;
  });

  element.dataset.motionSplit = "true";
}

function splitLines(element) {
  if (element.dataset.motionLineSplit === "true") return;
  if (element.querySelector(".motion-line")) return;

  const text = (element.textContent || "").trim();
  const lines = text.split(/\n+/).map((line) => line.trim()).filter(Boolean);
  if (lines.length < 2) return;

  element.textContent = "";
  element.setAttribute("aria-label", text);

  lines.forEach((line) => {
    const mask = document.createElement("span");
    const inner = document.createElement("span");

    mask.className = "motion-line-mask";
    mask.setAttribute("aria-hidden", "true");
    inner.className = "motion-line";
    inner.textContent = line;

    mask.appendChild(inner);
    element.appendChild(mask);
    element.appendChild(document.createTextNode(" "));
  });

  element.dataset.motionLineSplit = "true";
}

function initTextReveals() {
  if (reduceMotion) {
    gsap.set("[data-motion-text]", { autoAlpha: 1, clearProps: "all" });
    return;
  }

  gsap.utils.toArray("[data-motion-text='words']").forEach((element) => {
    splitWords(element);
    const words = element.querySelectorAll(".motion-word");

    gsap.set(element, { autoAlpha: 1 });
    gsap.fromTo(
      words,
      { yPercent: 110, autoAlpha: 0, filter: "blur(8px)" },
      {
        yPercent: 0,
        autoAlpha: 1,
        filter: "blur(0px)",
        duration: 0.9,
        ease: "power4.out",
        stagger: 0.055,
        scrollTrigger: {
          trigger: element,
          start: "top 82%",
          once: true,
        },
      }
    );
  });

  gsap.utils.toArray("[data-motion-text='lines']").forEach((element) => {
    splitLines(element);
    const lines = element.querySelectorAll(".motion-line");
    const targets = lines.length ? lines : element.children;

    gsap.set(element, { autoAlpha: 1 });
    gsap.fromTo(
      targets,
      { yPercent: 100, autoAlpha: 0, filter: "blur(8px)" },
      {
        yPercent: 0,
        autoAlpha: 1,
        filter: "blur(0px)",
        duration: 1,
        ease: "power4.out",
        stagger: 0.11,
        scrollTrigger: {
          trigger: element,
          start: "top 84%",
          once: true,
        },
      }
    );
  });
}

Zeilen-Markup, wenn exakte Zeilenumbrüche wichtig sind:

<h2 data-motion-text="lines">
  <span class="motion-line-mask"><span class="motion-line">Kinematografische Bewegung</span></span>
  <span class="motion-line-mask"><span class="motion-line">mit redaktioneller Zurückhaltung.</span></span>
</h2>

Scroll-Enthüllungen

Erstelle eine kleine Voreinstellungs-Map für Enthüllungen. Verwende autoAlpha, Transformationen und leichte Unschärfe. Verwende Unschärfe sparsam bei großen Elementen.

const revealPresets = {
  "fade-up": { from: { y: 32, autoAlpha: 0 }, to: { y: 0, autoAlpha: 1 } },
  "blur-in": { from: { y: 18, autoAlpha: 0, filter: "blur(10px)" }, to: { y: 0, autoAlpha: 1, filter: "blur(0px)" } },
  "scale": { from: { scale: 0.96, autoAlpha: 0 }, to: { scale: 1, autoAlpha: 1 } },
  "slide-left": { from: { x: 48, autoAlpha: 0 }, to: { x: 0, autoAlpha: 1 } },
  "slide-right": { from: { x: -48, autoAlpha: 0 }, to: { x: 0, autoAlpha: 1 } },
};

function initScrollReveals() {
  if (reduceMotion) {
    gsap.set("[data-reveal], [data-reveal-item]", { autoAlpha: 1, clearProps: "all" });
    return;
  }

  gsap.utils.toArray("[data-reveal-group]").forEach((group) => {
    const items = group.querySelectorAll("[data-reveal-item]");
    gsap.set(group, { autoAlpha: 1 });
    gsap.fromTo(
      items,
      { y: 36, autoAlpha: 0, filter: "blur(8px)" },
      {
        y: 0,
        autoAlpha: 1,
        filter: "blur(0px)",
        duration: 0.95,
        ease: "power4.out",
        stagger: 0.075,
        scrollTrigger: {
          trigger: group,
          start: "top 82%",
          once: true,
        },
      }
    );
  });

  gsap.utils.toArray("[data-reveal]:not([data-reveal-item])").forEach((element) => {
    const preset = revealPresets[element.dataset.reveal] || revealPresets["fade-up"];
    gsap.set(element, { autoAlpha: 1 });
    gsap.fromTo(element, preset.from, {
      ...preset.to,
      duration: 0.9,
      ease: "power4.out",
      delay: Number(element.dataset.revealDelay || 0),
      scrollTrigger: {
        trigger: element,
        start: "top 84%",
        once: true,
      },
    });
  });
}

Clip-Bild-Enthüllungen

function initImageReveals() {
  if (reduceMotion) {
    gsap.set("[data-image-reveal]", { autoAlpha: 1, clipPath: "none" });
    return;
  }

  gsap.utils.toArray("[data-image-reveal]").forEach((figure) => {
    const image = figure.querySelector("img");
    gsap.set(figure, { autoAlpha: 1 });

    const tl = gsap.timeline({
      scrollTrigger: {
        trigger: figure,
        start: "top 82%",
        once: true,
      },
    });

    tl.fromTo(
      figure,
      { clipPath: "inset(0 0 100% 0)" },
      { clipPath: "inset(0 0 0% 0)", duration: 1.1, ease: "power4.out" }
    ).fromTo(
      image,
      { scale: 1.08, autoAlpha: 0.75 },
      { scale: 1, autoAlpha: 1, duration: 1.2, ease: "power4.out" },
      0
    );
  });
}

Parallax-Bewegung

Verwende Geschwindigkeitsunterschiede anstelle von dramatischen Bewegungen. Hintergründe bewegen sich langsamer als der Inhalt. Akzente im Vordergrund bewegen sich etwas schneller.

function initParallax() {
  if (reduceMotion) return;

  gsap.utils.toArray("[data-parallax-image], [data-parallax-layer]").forEach((layer) => {
    const speed = Number(layer.dataset.parallaxSpeed || 0.18);
    const section = layer.closest("[data-parallax-section]") || layer;

    gsap.to(layer, {
      y: () => window.innerHeight * speed * -1,
      ease: "none",
      scrollTrigger: {
        trigger: section,
        start: "top bottom",
        end: "bottom top",
        scrub: 1.2,
        invalidateOnRefresh: true,
      },
    });
  });
}

Pinned-Scroll-Abschnitte

Verwende Pinned-Abschnitte nur für Story-Momente. Halte scroll-synchronisierte Bewegungen linear und füge dann sanfte Enthüllungs-Tweens innerhalb der Szene hinzu.

function initHorizontalGalleries() {
  if (reduceMotion) return;

  gsap.utils.toArray("[data-horizontal-gallery]").forEach((section) => {
    const track = section.querySelector("[data-horizontal-track]");
    if (!track) return;

    gsap.to(track, {
      x: () => -(track.scrollWidth - window.innerWidth),
      ease: "none",
      scrollTrigger: {
        trigger: section,
        start: "top top",
        end: () => `+=${track.scrollWidth}`,
        scrub: 1,
        pin: true,
        anticipatePin: 1,
        invalidateOnRefresh: true,
      },
    });
  });
}

Storytelling-Muster mit Sticky-Elementen:

function initStoryScenes() {
  if (reduceMotion) return;

  gsap.utils.toArray("[data-story-scene]").forEach((scene) => {
    const panels = scene.querySelectorAll("[data-story-panel]");

    gsap.timeline({
      scrollTrigger: {
        trigger: scene,
        start: "top top",
        end: () => `+=${panels.length * window.innerHeight}`,
        scrub: 1.1,
        pin: true,
        anticipatePin: 1,
      },
    })
      .to(panels, { yPercent: -100 * (panels.length - 1), ease: "none" })
      .to(scene.querySelectorAll("[data-story-depth]"), { yPercent: -16, ease: "none" }, 0);
  });
}

Hochwertige Hover-Interaktionen

Verwende GSAPs quickTo für magnetische Bewegung, damit der Hover dem Zeiger folgt, ohne bei jedem Ereignis neue Tweens zu erstellen.

function initMagnetic() {
  if (reduceMotion || window.matchMedia("(pointer: coarse)").matches) return;

  gsap.utils.toArray("[data-magnetic]").forEach((element) => {
    const strength = Number(element.dataset.magnetic || 0.18);
    const xTo = gsap.quickTo(element, "x", { duration: 0.45, ease: "power3.out" });
    const yTo = gsap.quickTo(element, "y", { duration: 0.45, ease: "power3.out" });

    element.addEventListener("pointermove", (event) => {
      const rect = element.getBoundingClientRect();
      const x = (event.clientX - rect.left - rect.width / 2) * strength;
      const y = (event.clientY - rect.top - rect.height / 2) * strength;

      xTo(x);
      yTo(y);
    });

    element.addEventListener("pointerleave", () => {
      xTo(0);
      yTo(0);
    });
  });
}

Hover-Rezepte:

  • Magnetische Buttons: Nur x/y verschieben, Skalierung unter 1.03 halten.
  • Magnetische Karten: rotateX/rotateY unter 4deg hinzufügen.
  • Bild-Zoom: scale: 1 auf 1.06, Dauer 0.7s, Ease power3.out.
  • Graustufen-zu-Farbe: Filter-Übergang nur bei kleinen/mittleren Medien.
  • Animierte Pfeile: Symbol x: 0 auf x: 6 bewegen, das doppelte Symbol einblenden.
  • Richtungsabhängiger Hover: Berechne die Eintrittsseite des Zeigers, aber halte die Bewegung unter 16px.

Benutzerdefinierter Cursor

Verwende einen Cursor-Follower als Atmosphäre, nicht als Dekoration. Verstecke ihn auf Touch-Geräten.

function initCursor() {
  if (reduceMotion || window.matchMedia("(pointer: coarse)").matches) return;

  const cursor = document.querySelector("[data-cursor]");
  if (!cursor) return;

  const label = cursor.querySelector("[data-cursor-label]");
  const xTo = gsap.quickTo(cursor, "x", { duration: 0.35, ease: "power3.out" });
  const yTo = gsap.quickTo(cursor, "y", { duration: 0.35, ease: "power3.out" });

  document.addEventListener("pointermove", (event) => {
    xTo(event.clientX);
    yTo(event.clientY);
  });

  gsap.utils.toArray("[data-cursor-label]")

…

[truncated for translation]

Individual skills in this repo

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

MengTo/Skills

Create polished 60 fps 4:3 4K browser screen-recording style videos from Codex in-app browser captures, with browser-only crop, natural macOS cursor styling, deliberate click choreography, zoom-follow framing, ffprobe/thumbnail verification, and optional native recording compatibility checks. Use when the user asks to record or re-record browser actions, show cursor clicks and zooms, make Dribbble/UI inspiration or product demo recordings, or asks whether Codex, Playwright, or an MCP can produce a natural browser demo video.

MengTo/Skills

Generate ElevenLabs text-to-speech audio from scripts or inline text using local voice profiles. Use when the user asks for ElevenLabs, text-to-speech, TTS, narration, voiceover, speech audio, or voice generation; load voice names, voice ids, emails, owners, and account-specific defaults only from local config outside the skill.

MengTo/Skills

Profile, audit, and optimize frontend page performance with emphasis on animation work, memory-leak risks, long-session slowdowns, CSS animations, canvas/WebGL requestAnimationFrame loops, marquees, skeletons, GSAP/Three/Matter effects, timers, listeners, and observers. Use when the user asks to make animations performant, pause offscreen animations, look for memory leaks, profile pages that slow the computer over time, fix janky scrolling, reduce CPU/GPU use, or repeat the "only play in view" optimization on React/Vite/Next/frontend pages using Codex Browser.

MengTo/Skills

Turn a reference video into a super detailed recreation or inspiration prompt. Use when the user provides, mentions, uploads, links, or points to a video and asks to analyze the design, UI, animations, transitions, scroll interactions, typography, colors, assets, WebGL/Three.js, storytelling, section-by-section behavior, or to create a prompt/article that recreates the page, app, interaction, or motion system.

MengTo/Skills

Create an on-scroll animation trigger using IntersectionObserver with Tailwind-friendly animation classes and keyframes. Use when asked for scroll-reveal, animate-on-scroll, or sequencing element animations when they enter the viewport.

MengTo/Skills

Use when designing or implementing product-grade web motion like Stripe, Linear, Apple, and Vercel. Covers motion principles, easing/duration defaults, choreography patterns, scroll/hover interactions, performance, accessibility (reduced motion), and implementation guidance.

MengTo/Skills

Create cinematic scroll-driven landing pages with Lenis smooth scrolling, GSAP ScrollTrigger, scroll-linked progression, staggered text reveals, sticky card stacks, parallax backgrounds, scroll-scrubbed transitions, footer reveals, and immersive preloaders. Use when analyzing or building premium editorial scroll experiences, sticky project stacks, kinetic typography, or section-by-section storytelling.

MengTo/Skills

Use when designing or rewriting a high-converting SaaS pricing page (structure, plan design, copywriting, SEO/AEO, FAQs, layout patterns, experiments). Includes checklists, templates, and common pitfalls.

MengTo/Skills

Use when creating or refining WebGL-heavy landing pages and you need to steer toward a specific visual outcome (premium, technical, playful, cinematic) while balancing conversion clarity, performance, and implementation complexity.

Verwandte Skills