Was macht motion-animate?
Das Design entscheidet, ob ein Bild gut ist. Die Bewegung entscheidet, ob es teuer aussieht. Die gleiche Komposition, animiert mit linearem Easing und gleichzeitigen Eintritten, wirkt generiert; animiert mit dem untenstehenden Vokabular wirkt sie autorengeführt.
Engine-Rezepte: Anhang A, Anhang B.
Die vier Gesetze
- Nichts ist linear. Jede Eigenschaft bewegt sich mit einem Easing. Lineare Bewegung existiert in der physischen Welt nicht, und das Auge erkennt es sofort.
- Nichts tritt gleichzeitig ein. Elemente kommen in einer bewussten Reihenfolge mit 60–120 ms Abstand an. Gleichzeitiger Eintritt ist das lauteste Bewegungs-Merkmal.
- Die Kamera ist niemals völlig still. Ein langsamer, kontinuierlicher Push oder Drift unter jeder Komposition. Statische Bilder wirken wie Folien.
- Nichts ist metronomisch. Variiere Dauern und Schnittabstände. Gleichmäßige 1-Sekunden-Schläge wirken automatisiert, egal wie gut jeder einzelne Schlag ist.
Timing-Tabelle
Werte bei 30 fps; für 60 fps skalieren. Zeiten in ms.
| Element | Dauer | Staffelung | Easing |
|---|---|---|---|
| Wort in einer Textzeile | 400–550 | 60–90 | out-expo / power3.out |
| Textzeile (als Einheit) | 500–650 | 120–180 | out-cubic / power2.out |
| Symbol / kleines UI-Element | 350–450 | 80–120 | out-back (Überschwingen ≤1.06) |
| Panel / Karte | 550–700 | 140–200 | out-quint / power4.out |
| Heldenobjekt Scale-In | 700–900 | — | out-expo |
| Heldenobjekt Slide-In | 650–850 | — | out-quint |
| Linie / Strichzeichnung | 600–1000 | — | in-out-cubic |
| Kamera-Push (pro Szene) | gesamte Szenenlänge | — | out-sine oder linear-ähnlich, wenn sehr langsam |
| Exit (jedes Element) | 250–350 | 40–60 | in-cubic |
Exits sind immer schneller als Eintritte, etwa halb so lang. Eine symmetrische Aus-Animation wirkt träge.
Die Kern-Bewegungen
Text — Pop-Blur-Fade, Wort für Wort
Der Signature-Move. Jede Eigenschaft animiert gleichzeitig, pro Wort, gestaffelt.
y: +18px → 0
blur: 12px → 0
opacity: 0 → 1
ease: out-expo, Dauer 480ms, Staffelung 70ms
Optional scale: 0.96 → 1 hinzufügen. Keine Rotation hinzufügen. Nicht hüpfen lassen.
Bei einer langen Zeile nach Wörtern staffeln, nicht nach Zeichen – eine Zeichen-Staffelung wirkt wie ein Schreibmaschinen-Gimmick und dauert zu lange. Hebe dir die Zeichen-Staffelung für ein einzelnes kurzes Akzentwort auf.
Akzentwort
Führt die gleiche Bewegung aus, aber um 120–200 ms verzögert gegenüber seinen Nachbarn und erhält eine zusätzliche Eigenschaft – eine Farbverschiebung, einen Scale-Boost auf 1.04 oder einen Highlight-Balken, der dahinter hineinwischt. Es sollte als letztes ankommen und anders ankommen.
Symbole und UI
Pop-Fade: scale 0.7 → 1, opacity 0 → 1, out-back mit auf 1.06 begrenztem Überschwingen. Alles über 1.1 wirkt wie ein billiger Hüpfer.
Sequenzielle Regel: Das Ankerelement tritt zuerst ein, dann seine Abhängigen. Eine Karte tritt ein, dann ihr Symbol, dann ihr Label. Niemals umgekehrt, niemals zusammen.
Panels / Karten / Glas
y: +40 → 0, opacity 0 → 1, out-quint, 600ms, um 160ms über einen Stapel gestaffelt. Füge einen Lichtstreifen-Highlight hinzu, der 150ms nachdem das Panel gelandet ist, darüber läuft – das Panel kommt an, dann fängt es das Licht ein.
Heldenobjekt
Zwei Optionen, wähle nach Archetyp:
- Scale-In:
scale 1.25 → 1.00mitrotate 3° → 0°,out-expo, 800ms. Fühlt sich an, als würde es sich an seinem Platz niederlassen. - Slide-In: von außerhalb des Bildrahmens mit einer 2°-Neigung, die sich auf 0° auflöst,
out-quint, 750ms. Fühlt sich geliefert an.
Der Schlagschatten und die beschnittene Textur müssen an das Heldenobjekt „geparent“ sein, damit sie sich mit ihm bewegen. Unabhängig gleitende Schatten sind ein schwerwiegender Fehler.
Strich / Linienzeichnung
Animieren der Pfadlänge von 0 auf 100%, in-out-cubic, 600–1000ms. Ease beim Ein- und Ausgang – eine Zeichnung, die mit voller Geschwindigkeit beginnt, wirkt mechanisch. Verwende, um ein Label mit einem Subjekt zu verbinden, ein Akzentwort zu unterstreichen oder ein Diagramm nachzuzeichnen.
Kamera
Unter jeder Komposition eine der folgenden:
- Push in:
scale 1.00 → 1.08über den gesamten Beat,out-sine. - Push out:
scale 1.12 → 1.00, schneller am Anfang, zur Ruhe kommend. - Drift:
x- odery-Translation von 2–4% über den Beat.
Anti-Ruckel-Vertrag:
- Animiere ein Wrapper-Element, niemals das Element, das das Layout oder Clipping besitzt.
- Verwende nur
transform– niemalstop/left/width/height. - Skaliere die bewegte Ebene ~6% über den Bildrand hinaus, sodass Kanten niemals sichtbar werden.
- Setze
will-change: transformund erzwinge GPU-Compositing. - Halte die Gesamtbewegung gering. Große Kamerafahrten verstärken jeden Rundungsfehler.
Übergänge zwischen Beats
- Harter Schnitt, maskiert durch einen SFX-Hit – die Standardeinstellung. Überblendungen zwischen designten Bildern trüben beide.
- Scale-through – ein Element skaliert hoch, um das Bild auszufüllen, und die nächste Szene wird darin enthüllt.
- Wipe durch eine Form – ein Kreis oder Panel skaliert über den Bildrand hinaus und trägt die nächste Szene mit sich.
Überblende keine zwei designten Kompositionen. Verwende keine vorgefertigten Übergangs-Presets.
Verboten
- Lineares Easing bei allem Sichtbaren.
- Hüpfer-Überschwingen >1.1 (Ausnahme: ein bewusst verspielter SaaS/Produkt-Stil, und dann konsistent).
- Alle Elemente treten im gleichen Bild ein.
- Gleichmäßige Beat-Längen innerhalb eines Schnitts.
repeat: -1oder jede Endlosschleife – Renderings sind Einzelbild-abgetastet und müssen deterministisch sein.Math.random(),Date.now()oder Netzwerkabrufe innerhalb einer Komposition. Gleiche Eingabe muss jedes Mal das gleiche Bild erzeugen.- Bewegung, die auf einen Wrapper angewendet wird, den das Framework bereits kontrolliert (siehe Anhang B §Clip-Regel).
Selbstcheck
Scrubbe das Rendering bei 0,25-facher Geschwindigkeit. Frage:
- Beginnt oder endet etwas abrupt? → fehlendes Easing.
- Kommt alles zusammen an? → fehlende Staffelung.
- Steht das Bild jemals absolut still? → fehlende Kamera.
- Fühlen sich aufeinanderfolgende Beats wie ein Trommelschlag an? → Dauern zu gleichmäßig.
- Werden Kanten einer bewegten Ebene jemals sichtbar? → nicht über-skaliert.
Anhang A – Remotion Rezepte
Bildbasiert, deterministisch durch Konstruktion. Alle Timing leitet sich von useCurrentFrame() ab.
Hilfsfunktion: Zeit in ms, nicht in Bildern
Das Authoring in Bildern hardcodiert deine fps. Konvertiere.
import {useVideoConfig, useCurrentFrame, interpolate, Easing} from 'remotion';
const useMs = () => {
const {fps} = useVideoConfig();
return (ms: number) => (ms / 1000) * fps;
};
Easing-Zuordnung
Die Namen aus der Timing-Tabelle, in Remotion-Ausdrücken:
Easing.out(Easing.exp) // out-expo
Easing.out(Easing.cubic) // out-cubic
Easing.out(Easing.quad) // out-quad
Easing.out(Easing.poly(4)) // out-quint-ish
Easing.inOut(Easing.cubic) // in-out-cubic
Easing.out(Easing.sin) // out-sine
Easing.in(Easing.cubic) // in-cubic (Ausgänge)
Easing.bezier(0.16, 1, 0.3, 1) // das Arbeitstier – expo-ähnlicher Ausgang
Bei Überschwingen bevorzuge einen spring gegenüber Easing.back – es ist einfacher, subtil zu bleiben.
import {spring} from 'remotion';
const s = spring({frame, fps, config: {damping: 200, stiffness: 120, mass: 0.6}});
// damping 200 = kein sichtbares Überschwingen. Auf ~14 reduzieren für ein kleines Setzen.
Text — Pop-Blur-Fade, Wort für Wort
const Words: React.FC<{text: string; delay?: number}> = ({text, delay = 0}) => {
const frame = useCurrentFrame();
const ms = useMs();
const STAGGER = ms(70);
const DUR = ms(480);
return (
<span style={{display: 'inline-flex', flexWrap: 'wrap', gap: '0.28em'}}>
{text.split(' ').map((word, i) => {
const local = frame - ms(delay) - i * STAGGER;
const p = interpolate(local, [0, DUR], [0, 1], {
extrapolateLeft: 'clamp',
extrapolateRight: 'clamp',
easing: Easing.bezier(0.16, 1, 0.3, 1),
});
return (
<span
key={i}
style={{
display: 'inline-block',
opacity: p,
filter: `blur(${(1 - p) * 12}px)`,
transform: `translateY(${(1 - p) * 18}px)`,
willChange: 'transform, filter, opacity',
}}
>
{word}
</span>
);
})}
</span>
);
};
Das Akzentwort ist die gleiche Komponente mit delay, das 120–200ms später gesetzt ist, plus eigener Farbe und einem scale(1.04).
Kamera — immer anliegender Push
Umschließe die ganze Szene. Überskaliere, sodass Kanten nie sichtbar werden.
const Camera: React.FC<{children: React.ReactNode; durationInFrames: number}> = ({
children, durationInFrames,
}) => {
const frame = useCurrentFrame();
const scale = interpolate(frame, [0, durationInFrames], [1.0, 1.08], {
extrapolateRight: 'clamp',
easing: Easing.out(Easing.sin),
});
return (
<AbsoluteFill style={{transform: `scale(${scale})`, willChange: 'transform'}}>
{children}
</AbsoluteFill>
);
};
Setze die Kamera über die Grundelement-Ebene und unter jedes Element, das am Bildrand fixiert bleiben muss.
Gestaffelter Kartenstapel
const cards = ['Eins', 'Zwei', 'Drei'];
const ms = useMs();
{cards.map((label, i) => {
const local = frame - i * ms(160);
const p = interpolate(local, [0, ms(600)], [0, 1], {
extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
easing: Easing.out(Easing.poly(4)),
});
return (
<div key={i} style={{
opacity: p,
transform: `translateY(${(1 - p) * 40}px)`,
}}>{label}</div>
);
})}
Exit — die Hälfte des Eintritts
const exitStart = durationInFrames - ms(300);
const out = interpolate(frame, [exitStart, durationInFrames], [1, 0], {
extrapolateLeft: 'clamp', extrapolateRight: 'clamp',
easing: Easing.in(Easing.cubic),
});
Struktur
Verwende <Sequence from={...} durationInFrames={...}> pro Beat, direkt gesteuert von der motion-plan-Tabelle. Ein Sequence pro Zeile. Beat-Dauern stammen aus dem Plan, nicht aus runden Zahlen.
<Series>
<Series.Sequence durationInFrames={ms(5200)}><BeatTwo /></Series.Sequence>
<Series.Sequence durationInFrames={ms(2100)}><BeatThree /></Series.Sequence>
</Series>
Deterministrik
- Niemals
Math.random()– wenn du Streuung brauchst, seede sie aus dem Elementindex. - Niemals
Date.now()odernew Date(). - Niemals innerhalb einer Komponente fetchen. Vorladen mit
staticFile()/delayRender(). <Video>/<Audio>sollte wo möglich<OffthreadVideo>sein, für die Rendering-Korrektheit.
Fallstricke
filter: blur()bei vielen gleichzeitigen Elementen ist teuer – begrenze die Anzahl gleichzeitiger unscharfer Knoten oder verwende eine Vor-Unschärfe im Asset.- Schriftarten laden: Verwende
@remotion/google-fontsoderdelayRenderum ein lokalesFontFace.load()herum, oder die ersten Bilder rendern mit einer Fallback-Schriftart. interpolatewirft einen Fehler, wenn der Eingabebereich nicht monoton steigend ist – schütze berechnete Bereiche.- Gib immer
extrapolateLeft/extrapolateRight: 'clamp'an, es sei denn, du möchtest gezielt, dass der Wert über den Bereich hinausläuft.
Anhang B – HyperFrames / GSAP Rezepte
HyperFrames komponiert HTML + GSAP und rendert durch Einzelbild-Sampling eines Headless-Browsers. Deterministrik ist zwingend erforderlich.
Führe npx hyperframes docs für die aktuelle API aus. Diese Datei ist der Bewegungsstandard darauf aufbauend – siehe das hyperframes-Skill für die Pipeline (init → preview → lint → render).
Die Clip-Regel (bricht Renderings, wenn verletzt)
Jedes getimte Element benötigt data-start, data-duration, data-track-index und class="clip". Das Framework besitzt die Sichtbarkeit und Transformation bei .clip.
Animiere NIEMALS das .clip-Element selbst. Animiere einen Child-Wrapper.
<div class="clip" data-start="4.2" data-duration="5.2" data-track-index="2">
<div class="cam"> <!-- Kamerabewegungen hier -->
<div class="inner"> <!-- Elementbewegungen hier -->
<h1 class="headline">…</h1>
</div>
</div>
</div>
Timeline-Registrierung
const tl = gsap.timeline({paused: true});
window.__timelines['main'] = tl; // id muss mit data-composition-id übereinstimmen
Angehalten, immer. Der Renderer sucht es.
Easing-Zuordnung
| Tabellenname | GSAP |
|---|---|
| out-expo | expo.out |
| out-cubic | power2.out |
| out-quint | power4.out |
| out-back (begrenzt) | back.out(1.2) |
| in-out-cubic | power2.inOut |
| out-sine | sine.out |
| in-cubic (Ausgänge) | power2.in |
Text — Pop-Blur-Fade, Wort für Wort
Teile den Text zur Authoring-Zeit in Wort-Spans auf (verlasse dich nicht auf einen Laufzeit-Splitter – dieser kann mit dem ersten gesampelten Bild in Konkurrenz treten).
<h1 class="headline">
<span class="w">Was</span> <span class="w">nach</span>
<span class="w accent">Disziplin</span> <span class="w">aussieht</span>
</h1>
tl.from('.headline .w', {
y: 18,
opacity: 0,
filter: 'blur(12px)',
duration: 0.48,
ease: 'expo.out',
stagger: 0.07,
}, 0);
// Akzentwort kommt zuletzt und anders
tl.from('.headline .accent', {
scale: 0.96,
color: 'var(--surface)',
duration: 0.5,
ease: 'expo.out',
}, 0.18);
Kamera
Animiere .cam, niemals .clip.
tl.fromTo('.cam',
{scale: 1.0},
{scale: 1.08, duration: 5.2, ease: 'sine.out', force3D: true},
0);
.cam { will-change: transform; transform: translateZ(0); }
Überskaliere die bewegte Ebene ~6% über den Bildrand hinaus, sodass Kanten während eines Push-Outs oder Drifts nie sichtbar werden.
Gestaffelter Kartenstapel
tl.from('.card', {
y: 40, opacity: 0,
duration: 0.6, ease: 'power4.out', stagger: 0.16,
}, 1.2);
// Lichtstreifen kommt 150ms nach dem Panel
tl.fromTo('.card .sweep', {xPercent: -140}, {
xPercent: 140, duration: 0.7, ease: 'power2.inOut', stagger: 0.16,
}, 1.35);
Strichzeichnung
tl.fromTo('.connector', {drawSVG: '0%'}, {drawSVG: '100%', duration: 0.8, ease: 'power2.inOut'});
// Kein DrawSVGPlugin? stroke-dasharray/offset verwenden:
tl.fromTo('.connector', {strokeDashoffset: 1000}, {strokeDashoffset: 0, duration: 0.8, ease: 'power2.inOut'});
Harte Regeln
- Nur deterministisch – kein
Math.random(), keinDate.now(), kein Fetch, keinrepeat: -1. - 9:16 = 1080×1920. Setze
#root { container-type: size; }und dimensioniere alles incqw/cqh(1cqw = 10.8px), niemalsvw/vh. - Benachbarte Clips auf dem gleichen Track dürfen sich nicht berühren. Gleitkomma-Arithmetik macht aus
3.2 + 0.35 = 3.5500000000000003, was einen Clip überlappt, der bei3.55beginnt, und löstoverlapping_clips_same_trackaus. Lasse eine Lücke oder verwende Dauern wie0.34. - Audio: Videos sind
muted; verwende eine einzige vorgemischte Master-<audio>-Spur (VO + SFX, gemischt mit ffmpegadelay+amix) auf einem hohen dediziertendata-track-index. Mehrere<a …>(Text abgeschnitten).
Dieser Standard definiert, wie Bewegung aussieht. Wende ihn auf jeden Beat deiner Komposition an – bevor du den Render-Knopf drückst.