Communitygithub.com

NeverSight/learn-skills.dev

Erstelle preisgekrönte Web-Erlebnisse in Awwwards-Qualität mit Federphysik, GLSL-Shadern, R3F, Post-Processing, Partikeln, Framer Motion und interaktivem 3D. Ideal für kreatives Coding, WebGL, cineastische UI oder preisgekröntes Motion Design.

Was ist learn-skills.dev?

Diese Fähigkeit ist ein umfassender Leitfaden für die Entwicklung kreativer, hochwertiger Web-Erlebnisse, die auf dem Niveau von Awwwards-Gewinnern liegen. Sie kombiniert eine physikbasierte Bewegungssteuerung mit einem breiten Spektrum an Werkzeugen für kreatives Coding, darunter GLSL-Shader, React Three Fiber (R3F), Post-Processing-Pipelines, Partikelsysteme, Framer Motion und GSAP. Der Schwerpunkt liegt darauf, Benutzeroberflächen wie physische 3D-Umgebungen zu behandeln, anstatt wie flache Rechtecke, und die Lücke zwischen dem, was preisgekrönte Studios veröffentlichen, und dem, was die meisten Teams für möglich halten, zu schließen. Die Fähigkeit basiert auf einer tiefgehenden Analyse der Arbeiten von Maxime Heckel, Codrops und der gesamten kreativen Web-Community, die Awwwards, FWA und CSS Design Awards antreibt. Sie unterstützt die Entwicklung mit React/Next.js, TypeScript und CSS und bietet detaillierte Anleitungen zu Federnphysik, Glasoberflächen, Rauschenfunktionen, Shader-Effekten, Partikelsystemen und fortgeschrittenen Post-Processing-Techniken. Entwickler können damit interaktive 3D-Erlebnisse, cineastische UI-Effekte und preisgekrönte Motion-Designs realisieren.

Funktioniert mit~Claude Code~Codex CLI✓Cursor
npx skills add https://github.com/NeverSight/learn-skills.dev/tree/HEAD/data/skills-md/adamperlis/awwwards-motion/awwwards-motion

In Ihrer bevorzugten KI fragen

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

Dokumentation

Awwwards-Qualität: Motion & Kreative Webentwicklung

Sie sind ein Experte für kreative Webentwicklung, spezialisiert auf GLSL-Shader, React Three Fiber (R3F), Three.js, WebGL Post-Processing, Partikelsysteme, Framer Motion Animationen und interaktive 3D-Web-Erlebnisse. Sie bauen Dinge aus ersten Prinzipien auf, mit einem tiefen Verständnis der Mathematik, und immer mit interaktiven, visuellen Ergebnissen.

Diese Fähigkeit ist inspiriert von der Handwerkskunst hinter den Awwwards-„Site of the Day“-Gewinnern – den Seiten, die die Messlatte für Motion, Interaktion und visuelle Qualität im Web setzen. Sie kombiniert ein physikbasiertes Bewegungssystem mit einem umfassenden Toolkit für kreatives Coding und behandelt die Benutzeroberfläche wie eine physische 3D-Umgebung anstelle von flachen Rechtecken. Das Ziel ist es, die Lücke zwischen dem, was preisgekrönte Studios veröffentlichen, und dem, was die meisten Teams für möglich halten, zu schließen.

Entwickelt aus dem intensiven Studium von Maxime Heckels Blog (blog.maximeheckel.com), Codrops (tympanus.net/codrops) und dem breiteren kreativen Web-Ökosystem, das Awwwards, FWA und CSS Design Awards antreibt.

Kerntechnologie-Stack

  • 3D & Shader: React Three Fiber, Three.js, GLSL (Vertex- + Fragment-Shader), WebGL Render Targets / FBOs, @react-three/drei, @react-three/postprocessing, Lamina (zusammensetzbare Shader-Layer), WebGPU/TSL (aufkommend)
  • Animation: Framer Motion (Layout-Animationen, AnimatePresence, Shared Layout Animationen, Reorder), GSAP + ScrollTrigger, Federphysik
  • Frontend: React/Next.js, TypeScript, CSS-Variablen, MDX, Designsysteme
  • Kreative Coding-Muster: Rauschfunktionen (Perlin, Simplex, Curl, FBM), Signierte Distanzfunktionen, Raymarching, Volumetrisches Rendering, Partikelsysteme (Buffer Geometry + FBO), Post-Processing-Pipelines

1. Physikbasierte Bewegung

Jede Bewegung verwendet Federphysik. Verwenden Sie niemals dauerbasierte Beschleunigungen (ease-in-out, cubic-bezier). Federn fühlen sich lebendig an, weil sie auf Geschwindigkeit, Spannung und Reibung reagieren.

Federkonstanten

Steifigkeit: 300
Dämpfung: 30
Masse: 1

Verhalten

  • Elemente überschwingen ihr Ziel leicht (1,05-fache Skalierung), bevor sie auf 1,0x zurückgehen
  • Übergänge dauern zwischen 400 ms und 700 ms, abhängig von der zurückgelegten Strecke
  • Bewegung sollte sich butterweich anfühlen und natürlich einpendeln, nicht roboterhaft

Implementierung

Framer Motion (React):

<motion.div
  animate={{ scale: 1 }}
  transition={{
    type: "spring",
    stiffness: 300,
    damping: 30,
    mass: 1
  }}
/>

GSAP:

gsap.to(element, {
  scale: 1,
  duration: 0.6,
  ease: "elastic.out(1, 0.5)"
});

CSS (nur als Fallback):

transition: transform 500ms cubic-bezier(0.34, 1.56, 0.64, 1);

2. Die Glasoberfläche

Jede erhabene Oberfläche verwendet einen mehrschichtigen Glasstack. Dies ist kein einfaches backdrop-filter: blur() – es ist ein zusammengesetztes Material.

Schichtstapel (von unten nach oben)

  1. Hintergrundunschärfe: Mehrschichtige Gaußsche Unschärfe (20px–40px)
  2. Oberflächenfüllung: Halbtransparentes Weiß — rgba(255, 255, 255, 0.05)
  3. Innerer Rand: 1px durchgezogen mit linearem Farbverlauf, der das Auftreffen von Licht auf die Oberkante simuliert
  4. Umgebungsschatten: Hohe Diffusion, großer Spread, sehr niedrige Deckkraft — simuliert Ambient Occlusion, keinen Drop Shadow

CSS-Implementierung

.glass-surface {
  backdrop-filter: blur(28px);
  background: rgba(255, 255, 255, 0.05);
  border: 1px solid rgba(255, 255, 255, 0.08);
  border-image: linear-gradient(
    180deg,
    rgba(255, 255, 255, 0.12) 0%,
    rgba(255, 255, 255, 0.02) 100%
  ) 1;
  box-shadow: 0 24px 80px rgba(0, 0, 0, 0.25);
}

Regeln

  • Nur dunkle Hintergründe. Glas auf hellen Hintergründen sieht falsch aus.
  • Verwenden Sie niemals durchgehende Hintergründe auf Glasoberflächen.
  • Das Glas sollte sich anfühlen, als hätte es physische Tiefe und Gewicht.
  • Unschärfewerte: 28px für Standardglas, 40px für Spotlight/Modal-Overlays.

3. GLSL-Shader-Grundlagen in React Three Fiber

Das mentale Modell

Ein Mesh = Geometrie + Material. Shader ersetzen das Material durch benutzerdefinierte GPU-Programme. Zwei Funktionen laufen auf der GPU:

  • Vertex-Shader: positioniert jeden Vertex. Läuft pro Vertex. Gibt gl_Position aus.
  • Fragment-Shader: färbt jedes Pixel ein. Läuft pro Pixel. Gibt gl_FragColor aus.

Grundlegendes R3F-Shader-Setup

import { Canvas } from '@react-three/fiber';
import { useRef, useMemo } from 'react';

const fragmentShader = `
  uniform float u_time;
  varying vec2 vUv;

  void main() {
    vec3 color = mix(vec3(1.0, 0.0, 0.5), vec3(1.0, 1.0, 0.0), vUv.x);
    gl_FragColor = vec4(color, 1.0);
  }
`;

const vertexShader = `
  varying vec2 vUv;

  void main() {
    vUv = uv;
    vec4 modelPosition = modelMatrix * vec4(position, 1.0);
    vec4 viewPosition = viewMatrix * modelPosition;
    gl_Position = projectionMatrix * viewPosition;
  }
`;

const MyMesh = () => {
  const mesh = useRef();
  const uniforms = useMemo(() => ({
    u_time: { value: 0.0 },
  }), []);

  return (
    <mesh ref={mesh}>
      <planeGeometry args={[2, 2, 32, 32]} />
      <shaderMaterial
        fragmentShader={fragmentShader}
        vertexShader={vertexShader}
        uniforms={uniforms}
      />
    </mesh>
  );
};

Schlüsselkonzepte

Uniforms — verbinden JS-Daten mit Shadern. Schreibgeschützt, für jeden Vertex/Pixel gleich. Verwenden Sie useFrame, um jeden Frame zu aktualisieren:

useFrame(({ clock }) => {
  mesh.current.material.uniforms.u_time.value = clock.elapsedTime;
});

Memoisieren Sie das Uniforms-Objekt immer, um Neu-Rendering-Fehler zu vermeiden.

Varyings — übergeben Daten vom Vertex- an den Fragment-Shader. Deklarieren Sie sie in beiden, setzen Sie sie im Vertex, lesen Sie sie im Fragment:

// Vertex
varying vec2 vUv;
void main() {
  vUv = uv;
  // ...
}

// Fragment
varying vec2 vUv;
void main() {
  gl_FragColor = vec4(vUv.x, vUv.y, 0.0, 1.0);
}

Attribute — Daten pro Vertex (Position, UV, benutzerdefiniert). Nur im Vertex-Shader verfügbar. Verwenden Sie Varyings, um sie an das Fragment weiterzuleiten.

4. Rauschfunktionen

Fast jeder organisch aussehende Shader verwendet Rauschen. Verwenden Sie sie als Werkzeuge.

  • Perlin-Rauschen: glattes, organisches Zufallsverhalten. Großartig für Gelände, Blob-Verformung.
  • Simplex-Rauschen: ähnlich wie Perlin, aber schneller und mit weniger Artefakten. Großartig für Farbverläufe, dynamische Texturen.
  • Curl-Rauschen: abgeleitet von Perlin/Simplex, erzeugt divergenzfreie Felder. Perfekt für flüssigkeitsähnliche Partikelbewegungen.
  • Fractal Brownian Motion (FBM): Schichten von Rauschen bei verschiedenen Frequenzen/Amplituden. Erzeugt wolkenartige, bergige Details.

Verwenden Sie das Paket glsl-noise oder kopieren Sie die Funktionen direkt in Ihre Shader-Strings.

Das „Blob“-Muster

// Vertex-Shader mit Perlin-Rausch-Verschiebung
uniform float u_time;
uniform float u_intensity;

void main() {
  float displacement = pnoise(position * 1.5 + u_time * 0.5, vec3(10.0));
  vec3 newPosition = position + normal * displacement * u_intensity;
  // ... Standard-MVP-Transformation auf newPosition
}

5. Fragment-Shader-Effekte

Diese Effekte heben die Benutzeroberfläche von „Website“ zu „cineastischem Erlebnis“. Wenden Sie sie sparsam und auf Umgebungsebene an, nicht pro Komponente.

Chromatische Aberration

Post-Processing-Durchgang, der die R/B-Kanäle an den Viewport-Rändern verschiebt.

Verschiebungsbetrag: 0.002
Anwendung: Nur Viewport-Ränder, nicht die Mitte
Zweck: Simuliert eine physische Kameralinse

Mesh-Gradient-Hintergrund

Animierter Hintergrund, der 3–4 geräuschbasierte Farb-Blobs verwendet, die langsam treiben.

Farben:
  - #00F0FF (Cyan)
  - #7000FF (Lila)
  - #000000 (Tiefes Dunkelgrau)

Bewegung: Langsame, organische Drift (denken Sie an Lava-Lampen, nicht an Bildschirmschoner)

Filmkorn

Monochromatische Rauschüberlagerung, um digitale Banding-Effekte zu beseitigen und Textur hinzuzufügen.

Deckkraft: 2% (0.02)
Typ: Monochromatisch
Animation: Subtile Variation pro Frame

6. Partikelsysteme

Einfache Partikel mit BufferGeometry

const count = 5000;
const positions = useMemo(() => {
  const pos = new Float32Array(count * 3);
  for (let i = 0; i < count; i++) {
    pos.set([
      (Math.random() - 0.5) * 4,
      (Math.random() - 0.5) * 4,
      (Math.random() - 0.5) * 4,
    ], i * 3);
  }
  return pos;
}, []);

return (
  <points>
    <bufferGeometry>
      <bufferAttribute
        attach="attributes-position"
        count={count}
        array={positions}
        itemSize={3}
      />
    </bufferGeometry>
    <shaderMaterial
      vertexShader={vertexShader}
      fragmentShader={fragmentShader}
      uniforms={uniforms}
      blending={THREE.AdditiveBlending}
      depthWrite={false}
    />
  </points>
);

Partikel zum Leuchten bringen

// Fragment-Shader
void main() {
  float strength = distance(gl_PointCoord, vec2(0.5));
  strength = 1.0 - strength;
  strength = pow(strength, 3.0);

  vec3 color = mix(vec3(0.0), vec3(0.34, 0.53, 0.96), strength);
  gl_FragColor = vec4(color, strength);
}

Frame Buffer Objects (FBO) für massive Partikelanzahlen

FBO ermöglicht es, Positionsberechnungen über einen Simulationsdurchgang an die GPU auszulagern und so 100.000+ Partikel zu ermöglichen:

  1. Speichern Sie Partikelpositionen in einer DataTexture (vec4 pro Partikel = RGBA).
  2. Erstellen Sie ein SimulationMaterial, das Positionen in seinem Fragment-Shader liest und transformiert.
  3. Rendern Sie dieses Material in ein Offscreen-WebGLRenderTarget (useFBO von drei).
  4. Lesen Sie die resultierende Textur als Uniform im Renderdurchgang aus und verwenden Sie sie zur Positionierung der Partikel.
// Simulation-Materialklasse
class SimulationMaterial extends THREE.ShaderMaterial {
  constructor(size) {
    const positionsTexture = new THREE.DataTexture(
      generatePositions(size, size),
      size, size,
      THREE.RGBAFormat, THREE.FloatType
    );
    positionsTexture.needsUpdate = true;
    super({
      uniforms: {
        positions: { value: positionsTexture },
        uTime: { value: 0 }
      },
      vertexShader: simVertexShader,
      fragmentShader: simFragmentShader,
    });
  }
}

// In useFrame: Sim-Material auf FBO rendern, FBO.texture an Partikel übergeben
useFrame(({ gl, clock }) => {
  gl.setRenderTarget(renderTarget);
  gl.clear();
  gl.render(simScene, simCamera);
  gl.setRenderTarget(null);
  points.current.material.uniforms.uPositions.value = renderTarget.texture;
  simMaterialRef.current.uniforms.uTime.value = clock.elapsedTime;
});

7. Render Targets

Ein WebGLRenderTarget rendert eine Szene in einen Offscreen-Puffer und gibt Ihnen deren Pixelinhalt als Textur.

Kernmuster

const renderTarget = useFBO();

useFrame(({ gl, scene, camera }) => {
  gl.setRenderTarget(renderTarget);
  gl.render(scene, camera);
  mesh.current.material.map = renderTarget.texture;
  gl.setRenderTarget(null);
});

Anwendungsfälle

Transparente/Glas-Materialien — Mesh ausblenden, Szene auf FBO rendern, FBO-Textur unter Verwendung von Bildschirmkoordinaten auf Mesh abbilden:

vec2 uv = gl_FragCoord.xy / winResolution.xy;
vec4 color = texture2D(uTexture, uv);

Portale (Szene in Szene) — Verwenden Sie createPortal von R3F, um eine Offscreen-Szene zu rendern, sie in einem FBO zu erfassen und auf eine Ebene zu legen. Fügen Sie Parallaxe hinzu, indem Sie matrixWorldInverse der Hauptkamera kopieren.

Optische Täuschungen — Tauschen Sie Materialien/Geometrien zwischen Renderdurchgängen innerhalb von useFrame aus, um alternative Versionen durch ein Linsen-Mesh anzuzeigen.

Szenenübergänge — Rendern Sie zwei Szenen in zwei FBOs, mischen Sie mit Perlin-Rauschen + Fortschrittsuniform:

float noise = clamp(cnoise(vUv * 2.5) + uProgress * 2.0, 0.0, 1.0);
vec4 color = mix(colorA, colorB, noise);

Post-Processing-Pipelines — Verketten Sie Render-Targets mit benutzerdefinierten Shader-Materialien auf einem Vollbild-Dreieck als Alternative zu EffectComposer.

8. Brechung, Dispersion & Lichteffekte

Brechung

Verwenden Sie GLSLs eingebautes refract() mit eyeVector, worldNormal und IOR-Verhältnis:

vec3 refractVec = refract(eyeVector, worldNormal, 1.0 / 1.31);
vec4 color = texture2D(uTexture, uv + refractVec.xy);

Chromatische Dispersion

Wenden Sie separate IOR-Werte pro Farbkanal an und teilen Sie R, G, B auf:

float R = texture2D(uTexture, uv + refractVecR.xy).r;
float G = texture2D(uTexture, uv + refractVecG.xy).g;
float B = texture2D(uTexture, uv + refractVecB.xy).b;

Glätten Sie es mit einer Sampling-Schleife (iterieren Sie N-mal mit inkrementellem Versatz pro Kanal). Erweitern Sie den Farbraum von RGB auf RYGCBV unter Verwendung von Fourier-Interpolation für mehr Kontrolle.

Specular + Diffuse (Blinn-Phong)

vec3 lightVector = normalize(-uLight);
vec3 halfVector = normalize(eyeVector + lightVector);
float kDiffuse = max(0.0, dot(normal, lightVector));
float kSpecular = pow(dot(normal, halfVector) * dot(normal, halfVector), shininess);
return kSpecular + kDiffuse * diffuseness;

Fresnel

float fresnel = pow(1.0 - abs(dot(eyeVector, worldNormal)), uFresnelPower);

Trick mit der Rückseiten-Darstellung

Rendern Sie zuerst die Rückseite eines Meshs (THREE.BackSide), erfassen Sie es in einem FBO, rendern Sie dann die Vorderseite. Die Specular-Reflexion der Rückseite wird durch die Vorderseite gebrochen/dispergiert, wodurch eine überzeugende interne Dispersion entsteht.

9. Post-Processing als kreatives Medium

Die Grundlage der Pixelierung

vec2 normalizedPixelSize = pixelSize / resolution;
vec2 uvPixel = normalizedPixelSize * floor(uv / normalizedPixelSize);
vec4 color = texture2D(inputBuffer, uvPixel);

Zugriff auf zellenlokale Koordinaten

vec2 cellUV = fract(uv / normalizedPixelSize); // 0->1 innerhalb jeder Zelle

Dies ist der Schlüssel zur Formung von Mustern innerhalb jeder Pixelzelle.

Zwei Säulen von Post-Processing-Shadern

  1. UV-Koordinaten neu abbilden/verzerren (Pixelierung, Versätze, Überlagerungen)
  2. Jede Zelle individuell formen (Muster basierend auf Luma, SDFs, Schwellwertmatrizen)

Mustertechniken

Balken-/Quittungsmuster — Verwenden Sie Luma, um die Linienbreite innerhalb des cellUV jeder Zelle zu steuern.

Halftone — Zeichnen Sie Kreise mittels Distanzfeldern, variieren Sie den Radius nach Luma:

float luma = dot(vec3(0.2126, 0.7152, 0.0722), color.rgb);
float radius = uRadius * (0.1 + luma);
float circle = smoothstep(radius - 0.01, radius + 0.01, dist);

CMYK-Halftone — Vier gedrehte Gitter (C:15 Grad, M:75 Grad, Y:0 Grad, K:45 Grad), konvertieren Sie RGB in CMYK, subtraktives Mischen:

vec3 outColor = vec3(1.0);
outColor.r *= (1.0 - CYAN_STRENGTH * dotC);
outColor.g *= (1.0 - MAGENTA_STRENGTH * dotM);
outColor.b *= (1.0 - YELLOW_STRENGTH * dotY);
outColor *= ...

(Fortsetzung auf next.fragment.glsl)


10. Framer Motion Effekte

Layout-Animationen

import { LayoutGroup, motion } from 'framer-motion';

<LayoutGroup>
  {items.map(item => (
    <motion.div layout key={item.id}>
      {item.name}
    </motion.div>
  ))}
</LayoutGroup>

Shared Layout-Animationen

Verwenden Sie layoutId, um Elemente über Container hinweg zu animieren:

{isOpen ? (
  <motion.div layoutId="card" />
) : (
  <motion.div layoutId="card" />
)}

AnimatePresence für Exit-Animationen

import { AnimatePresence } from 'framer-motion';

<AnimatePresence>
  {isVisible && (
    <motion.div
      initial={{ opacity: 0, scale: 0.8 }}
      animate={{ opacity: 1, scale: 1 }}
      exit={{ opacity: 0, scale: 0.8 }}
      transition={{ type: "spring", stiffness: 300, damping: 30 }}
    />
  )}
</AnimatePresence>

Drag mit Federphysik

<motion.div
  drag
  dragConstraints={{ left: 0, right: 300 }}
  whileTap={{ scale: 0.95 }}
/>

11. GSAP + ScrollTrigger

Basis-Konfiguration

import { gsap } from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';

gsap.registerPlugin(ScrollTrigger);

gsap.to('.element', {
  scrollTrigger: '.element',
  scale: 1.2,
  duration: 0.6,
  ease: 'elastic.out(1, 0.5)'
});

Fortgeschritten: Parallax-Layer

ScrollTrigger.create({
  trigger: '.section',
  start: 'top bottom',
  end: 'bottom top',
  onUpdate: self => {
    gsap.set('.parallax-layer', { y: self.progress * 200 });
  }
});

12. Leistungsoptimierung

Regeln

  • Verwenden Sie instancedMesh für viele identische Geometrien.
  • Partikel mit BufferGeometry und FBOs für 100k+ Partikel.
  • Vermeiden Sie Lichtquellen in Shader-Materialien, wo möglich — backen Sie stattdessen Beleuchtung in Texturen.
  • Verwenden Sie useFrame sparsam: nur in Komponenten, die tatsächlich jeden Frame aktualisiert werden müssen.
  • useMemo für Uniforms und Geometriedaten, um unnötige Neuberechnungen zu vermeiden.

Spezifische Ratschläge

  • Shader-Kompilierung: Speichern Sie Shader-Strings außerhalb von Komponenten, um Neukompilierung bei jedem Render zu vermeiden.
  • Textur-Größen: Verwenden Sie potenzielle 2er-Größen (256, 512, 1024, 2048) für GPU-Effizienz.
  • Frame Buffers: Halten Sie FBO-Texturen auf der kleinstmöglichen Größe für den beabsichtigten Effekt.

Viel Erfolg beim Bau erstaunlicher Web-Erlebnisse!

Individual skills in this repo

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

NeverSight/learn-skills.dev

Use when generating or modifying Remotion video code, creating demo videos, or working with the demo-video/ directory

NeverSight/learn-skills.dev

Create AI avatar and talking head videos via inference.sh CLI. Recommended: P-Video-Avatar (fastest, cheapest, built-in TTS). Also: OmniHuman, Fabric, PixVerse. Audio: Inworld TTS-2 (100+ languages, emotion steering for characters), ElevenLabs, Kokoro. Capabilities: audio-driven avatars, text-to-avatar, lipsync videos, talking head generation, virtual presenters, UGC content. Use for: AI presenters, explainer videos, virtual influencers, dubbing, marketing videos, UGC ads, gaming avatars, NPC dialogue. Triggers: ai avatar, talking head, lipsync, avatar video, virtual presenter, ai spokesperson, audio driven video, heygen alternative, synthesia alternative, talking avatar, lip sync, video avatar, ai presenter, digital human, ugc, ugc video, ugc ad, avatar ugc

NeverSight/learn-skills.dev

Create AI marketing videos for ads, promos, product launches, and brand content. Models: Veo, Seedance, Wan, FLUX for visuals, Kokoro for voiceover. Types: product demos, testimonials, explainers, social ads, brand videos. Use for: Facebook ads, YouTube ads, product launches, brand awareness. Triggers: marketing video, ad video, promo video, commercial, brand video, product video, explainer video, ad creative, video ad, facebook ad video, youtube ad, instagram ad, tiktok ad, promotional video, launch video

NeverSight/learn-skills.dev

Generate AI videos with Google Veo, Seedance 2.0, HappyHorse, Wan, Grok and 40+ models via inference.sh CLI. Models: Veo 3.1, Veo 3, Seedance 2.0, HappyHorse 1.0, Wan 2.5, Grok Imagine Video, OmniHuman, Fabric, HunyuanVideo. Capabilities: text-to-video, image-to-video, reference-to-video, video editing, lipsync, avatar animation, video upscaling, foley sound. Use for: social media videos, marketing content, explainer videos, product demos, AI avatars. Triggers: video generation, ai video, text to video, image to video, veo, animate image, video from image, ai animation, video generator, generate video, t2v, i2v, ai video maker, create video with ai, runway alternative, pika alternative, sora alternative, kling alternative, seedance, happyhorse

NeverSight/learn-skills.dev

ElevenLabs automatic dubbing - translate and dub audio/video into 29 languages while preserving speaker voice via inference.sh CLI. Capabilities: auto speaker detection, voice-preserving translation, video dubbing, audio localization. Use for: content localization, video translation, multilingual content, international distribution. Triggers: dubbing, dub video, translate audio, video translation, audio translation, localize content, elevenlabs dubbing, eleven labs dub, multilingual dub, voice translation, auto dub, language dub, content localization

NeverSight/learn-skills.dev

Explainer video production guide: scripting, voiceover, visuals, and assembly. Covers script formulas, pacing rules, scene planning, and multi-tool pipelines. Use for: product demos, how-it-works videos, onboarding videos, social explainers. Triggers: explainer video, how to make explainer, product video, demo video, video production, video script, animated explainer, product demo video, tutorial video, onboarding video, walkthrough video, video pipeline

NeverSight/learn-skills.dev

Still-to-video conversion guide: model selection, motion prompting, and camera movement. Covers Wan 2.5 i2v, Seedance, Fabric, Grok Video with when to use each. Use for: animating images, creating video from stills, adding motion, product animations. Triggers: image to video, i2v, animate image, still to video, add motion to image, image animation, photo to video, animate still, wan i2v, image2video, bring image to life, animate photo, motion from image

NeverSight/learn-skills.dev

Generate talking head avatar videos with Pruna P-Video-Avatar via inference.sh CLI. Turn a portrait image into a realistic speaking video with built-in TTS. 18x faster and 6x cheaper than competitors. Models: P-Video-Avatar, P-Image (for portrait generation). Capabilities: text-to-avatar, audio-driven avatars, 30 voices, 10 languages, 720p/1080p, built-in TTS, dynamic backgrounds, full-body control. Use for: AI presenters, product demos, explainer videos, virtual influencers, marketing, education, multilingual content, UGC, gaming avatars. Triggers: avatar video, talking head, ai avatar, p-video-avatar, pruna avatar, video avatar, ai presenter, digital human, virtual presenter, lipsync, talking avatar, ai spokesperson, heygen alternative, synthesia alternative, veed alternative, fabric alternative, omnihuman alternative

NeverSight/learn-skills.dev

Generate videos with Pruna P-Video and WAN models via inference.sh CLI. Models: P-Video, WAN-T2V, WAN-I2V. Capabilities: text-to-video, image-to-video, audio support, 720p/1080p, fast inference. Pruna optimizes models for speed without quality loss. Triggers: pruna video, p-video, pruna ai video, fast video generation, optimized video, wan t2v, wan i2v, economic video generation, cheap video generation, pruna text to video, pruna image to video

NeverSight/learn-skills.dev

Render videos from React/Remotion component code via inference.sh. Pass TSX code, get MP4. Supports all Remotion APIs: useCurrentFrame, useVideoConfig, spring, interpolate, AbsoluteFill, Sequence. Configurable resolution, FPS, duration, codec. Use for: programmatic video generation, animated graphics, motion design, data-driven videos, React animations to video. Triggers: remotion, render video from code, tsx to video, react video, programmatic video, remotion render, code to video, animated video, motion graphics code, react animation video

NeverSight/learn-skills.dev

Video ad creation with exact platform-specific specs for TikTok, Instagram, YouTube, Facebook, LinkedIn. Covers dimensions, duration limits, AIDA framework, and caption requirements. Use for: video ads, social media ads, paid media creative, video marketing, ad production. Triggers: video ad, social media ad, tiktok ad, instagram ad, youtube ad, facebook ad, linkedin ad, video creative, ad specs, paid media, video marketing, ad production, reels ad, stories ad, pre roll, bumper ad

NeverSight/learn-skills.dev

Best practices and techniques for writing effective AI video generation prompts. Covers: Veo, Seedance, Wan, Grok, Kling, Runway, Pika, Sora prompting strategies. Learn: shot types, camera movements, lighting, pacing, style keywords, negative prompts. Use for: improving video quality, getting consistent results, professional video prompts. Triggers: video prompt, how to prompt video, veo prompts, video generation tips, better ai video, video prompt engineering, video prompt guide, video prompt template, ai video tips, video prompt best practices, video prompt examples, cinematography prompts

NeverSight/learn-skills.dev

YouTube thumbnail design with specific dimensions, contrast rules, and mobile preview optimization. Covers safe zones, text placement, face expression psychology, and A/B testing. Use for: YouTube thumbnails, video cover images, click-through optimization. Triggers: youtube thumbnail, thumbnail design, video thumbnail, click through rate, ctr optimization, youtube cover, video cover image, thumbnail maker, thumbnail tips, youtube design, video preview image

NeverSight/learn-skills.dev

Landing page conversion optimization with layout rules, hero section design, and CTA psychology. Covers above-the-fold formula, social proof placement, mobile design, and F-pattern reading. Use for: startup landing pages, product pages, SaaS marketing, conversion optimization. Triggers: landing page, hero section, above the fold, conversion optimization, landing page design, cta button, hero image, landing page layout, saas landing page, product page design, conversion rate, landing page best practices

NeverSight/learn-skills.dev

Configure and use the hosted YouTube Data MCP end-to-end with minimal user input. Use when users want the agent to verify Node.js and `npx`, configure MCP server config (Windows/macOS, Cursor/Codex/OpenClaw/OpenCode), request API key at setup time, run post-install capability discovery (`tools/list` and `get_patch_notes`), and then strongly recommend helper skill and Python setup for full local document and spreadsheet workflows.

NeverSight/learn-skills.dev

Creates 120fps GPU-accelerated animations with Motion.dev (Framer Motion successor) for React, Next.js, Svelte, and Astro projects. Use when user requests animation, motion, scroll effects, parallax, hero animations, gestures, drag interactions, spring physics, whileHover effects, whileInView animations, animated UI, micro-interactions, page transitions, or layout animations. Generates production TypeScript/JSX code with accessibility (prefers-reduced-motion) and performance validation (≥60fps). Supports entrance animations, gesture interactions (hover/tap/drag), scroll-based reveals, and layout transitions using spring physics and natural timing. Do NOT use for CSS-only transitions (use native CSS), static sites without JavaScript, Vue animations (use motion-v variant instead), or SVG/Canvas complex animations (GSAP better suited).

NeverSight/learn-skills.dev

Static artifact craft skill for self-contained HTML/CSS/JS documents: docs, sheets, dashboards, explainers, slides, tools, and landing pages. Use when the user asks for a durable, openable, shareable web deliverable they'll keep or hand off — a report, a dashboard, a slide deck, a data table, a page. Local folder first, temporary public link via tunnel (localhost.run), optional durable publish to Surge, GitHub Pages, or Cloudflare. Not for quick look renders, inline snippets, or throwaway scratch. Not for SPA frameworks, backend APIs, database apps, or production product UI.

NeverSight/learn-skills.dev

FFmpeg commands for video/audio conversion, trimming, compression, and processing. Use when user mentions "ffmpeg", "convert video", "compress video", "extract audio", "trim video", "gif from video", "video codec", "transcode", "screen recording", "merge videos", "video to mp4", "reduce file size", or any media processing task.

NeverSight/learn-skills.dev

Vim keybindings, motions, text objects, and operators for efficient text editing. Use when user asks about "vim commands", "vim motions", "text objects", "vim keybindings", "vim cheat sheet", "learn vim", "vim in VS Code", or any Vim editing tasks.

NeverSight/learn-skills.dev

Grok Build ONLY. Turn a 2D character still into smooth animation sprites via image_gen/image_edit base → image_to_video (6s/10s run-in-place) → ffmpeg frames → magenta chroma-key → dense sampled sprites (strip/grid/GIF). Use when the user wants video-to-sprite, motion capture from generated video, smoother run/walk cycles from dense frames, or runs /video2dsprite. Do NOT use on Codex/Claude — only Grok Build has image_to_video. Prefer generate2dsprite for crisp pixel sheets without video.

Verwandte Skills