We tested the GSAP Flip plugin inside a HyperFrames render
GSAP's Flip plugin animates an element from where it was to where it is after a layout change. We rendered three Flip cases in HyperFrames and checked the frames against plain CSS layouts.
Tested by us on Nov 6, 2026, on the clips and machine listed below. Every number on this page was measured in that run.
The result
GSAP's Flip plugin works in a HyperFrames render for one layout change at a time, and it breaks when you chain a second change onto the same cards. We rendered eight cards through three cases. Sorting the cards (a pure move) and hiding four of them with an exit tween both matched plain CSS layouts at the start and end, with a mean grey difference of 0.03 to 0.03 out of 255, while the frames in between were clearly different from both layouts (18 to 19), so the cards really move.
The chained case did not work: its first frame differed from the correct start layout by 17.6, and by eye four of the eight cards were missing at the start. The test render itself took a median of 15.7 seconds for 7 seconds of 1080p video, with peak memory of 886 MB.
What it made



Footage: Tears of Steel, (c) Blender Foundation, mango.blender.org, CC-BY 3.0. These are files we made from it; they are shown under the same licence terms.
Three frames from the reorder test: before the Flip, halfway through it and after it.
What failed or surprised us
- Two Flips in a row on the same cards broke the first frames. We called Flip.from for a second layout change after the first and put both on the timeline. At 0.04 s the picture was not the starting layout: the cards sat in shifted places and the B cards were missing. We looked at the frames to confirm what the number said. We tried passing immediateRender: false and building the second Flip with Flip.fromTo; neither fixed it (the fromTo version froze the cards in a half-moved layout). We did not find a working way to chain, so use one Flip per set of cards, or render each change as its own scene.
- Our first attempt put the Flip tween on the timeline paused, as we would for any other tween. A paused child does not play when the parent timeline is seeked, which is how a HyperFrames render steps through the video, so every frame showed the final layout. Add the Flip tween unpaused.
- In an earlier version of the hide case, where we wound the first Flip to its end before building the timeline and gave it a delay, the four hidden cards were missing in the frames before the move. The plain version, one Flip.from with an exit tween and nothing else done to it, showed all eight cards at the start. We do not know the cause; we only know which version works.
- This test shows that Flip renders correctly frame by frame. It does not show that Flip is smooth to the eye at 24 frames a second, and we did not test nested transforms or scrolled pages.
What we tested and how
- Tool: GSAP Flip plugin version gsap 3.15.1 with Flip.min.js, HyperFrames 0.8.10, GSAP standard no-charge licence (https://gsap.com/standard-license).
- Settings compared: 8 cards, 4 columns, Flip.from sorting them at 1.0 s, 1.2 s power2.inOut, 1920x1080 24 fps 7 s.
- Input clips: No footage: the test composition is eight coloured cards we built (lab/flip/build_flip.py).
flip-composition: 7 s, SHA-2560a6b7a324d3ffba4...
- Machine: AMD Ryzen 7 7735U (8 cores, 16 threads), integrated Radeon 680M, not used (CPU-only runs), 31.2 GB RAM, Windows 11 10.0.26300. The laptop was shared with other work, so timings are what a busy machine gives, not a clean benchmark.
- Runs: one cold run, then three timed runs per clip and setting. Run on 2026-11-06.
We installed gsap 3.15.1 from the npm registry into a folder on our lab drive and used its gsap.min.js and Flip.min.js. The composition is eight coloured cards in a four-column grid, built by a small script (see Reproduce it). The test case, called reorder, is one Flip.from at 1.0 s that sorts the cards A then B over 1.2 s with power2.inOut. Two more cases were rendered once each: leave (a Flip.from that hides the four B cards and moves the rest into two columns) and chain (a second Flip.from at 4.0 s that moves all eight into one row).
HyperFrames 0.8.10 rendered each at 1920x1080, 24 fps, 7 seconds. We rendered four static versions of the same layouts with plain CSS and no Flip, took the first, middle and last frames of each Flip render, and compared them with the static frames by mean grey difference. We also looked at the frames ourselves.
Measurements by clip
The test run: one Flip.from, rendered four times
| Composition | Cold run (s) | Timed runs (s) | Median run (s) | Peak memory (MB) | Output | SHA-256 of the output (first 16) |
|---|---|---|---|---|---|---|
| 8 cards, 7 s | 13.1 | 14.8, 15.7, 15.8 | 15.7 | 886 | h264 yuv420p 1920x1080 | 5738925615b8e889 |
Do the frames match plain CSS layouts? (mean grey difference, 0 to 255)
| Case | First frame vs start layout | Last frame vs end layout | Mid-flight vs start | Mid-flight vs end |
|---|---|---|---|---|
| Sort the cards (the test run) | 0.03 | 0.03 | 18.44 | 17.23 |
| Hide four cards (display none and onLeave) | 0.02 | 0.03 | 19.04 | 11.21 |
| Two Flips one after the other | 17.61 | 0.03 | 24.44 | 14.9 |
Reproduce it
<!doctype html>
<html lang="en" data-composition-variables='[{"id":"mode","type":"string","label":"reorder, chain, leave or static0 to static3","default":"reorder"}]'>
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=1920, height=1080" />
<script src="gsap.min.js"></script>
<script src="Flip.min.js"></script>
<style>
*, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
html, body { width: 1920px; height: 1080px; overflow: hidden; background: #0b0d12; }
#root { position: relative; width: 100%; height: 100%; overflow: hidden; background: radial-gradient(120% 90% at 30% 40%, #1b2335 0%, #0b0d12 70%); }
#grid { position: absolute; left: 160px; top: 240px; width: 1600px; display: grid; grid-template-columns: repeat(4, 1fr); gap: 32px; }
#grid.row { grid-template-columns: repeat(8, 1fr); gap: 16px; }
#grid.two { grid-template-columns: repeat(2, 1fr); left: 560px; width: 800px; }
.card.hide { display: none; }
.card { height: 240px; border-radius: 28px; display: flex; align-items: center; justify-content: center; font-family: "Segoe UI", Arial, sans-serif; font-weight: 700; font-size: 72px; color: #fff; box-shadow: 0 16px 40px rgba(0,0,0,0.4); }
#label { position: absolute; left: 160px; top: 90px; font-family: "Segoe UI", Arial, sans-serif; font-weight: 700; font-size: 64px; color: #fff; }
</style>
</head>
<body>
<div id="root" data-composition-id="main" data-start="0" data-duration="7" data-fps="24" data-width="1920" data-height="1080">
<div id="label">GSAP Flip</div>
<div id="grid">
<div class="card" data-cat="A" style="background:#ff5a1f">A1</div>
<div class="card" data-cat="B" style="background:#2f6bff">B1</div>
<div class="card" data-cat="A" style="background:#ff5a1f">A2</div>
<div class="card" data-cat="B" style="background:#2f6bff">B2</div>
<div class="card" data-cat="A" style="background:#ff5a1f">A3</div>
<div class="card" data-cat="B" style="background:#2f6bff">B3</div>
<div class="card" data-cat="A" style="background:#ff5a1f">A4</div>
<div class="card" data-cat="B" style="background:#2f6bff">B4</div>
</div>
</div>
<script>
window.__timelines = window.__timelines || {};
(function () {
gsap.registerPlugin(Flip);
const mode = window.__hyperframes.getVariables().mode || "reorder";
const grid = document.getElementById("grid");
const all = () => gsap.utils.toArray(".card");
const sortAB = () => all().sort((x, y) => (x.dataset.cat + x.textContent).localeCompare(y.dataset.cat + y.textContent)).forEach((c) => grid.appendChild(c));
const toRow = () => grid.classList.add("row");
const filterA = () => { grid.classList.add("two"); all().forEach((c) => c.classList.toggle("hide", c.dataset.cat === "B")); };
const tl = gsap.timeline({ paused: true });
const opts = { duration: 1.2, ease: "power2.inOut" };
if (mode === "reorder") {
const s = Flip.getState(".card");
sortAB();
tl.add(Flip.from(s, opts), 1.0);
tl.progress(0);
} else if (mode === "chain") {
let s = Flip.getState(".card");
sortAB();
const f1 = Flip.from(s, opts);
tl.add(f1, 1.0);
f1.progress(1);
s = Flip.getState(".card");
toRow();
tl.add(Flip.from(s, opts), 4.0);
tl.progress(0);
} else if (mode === "leave") {
const s = Flip.getState(".card");
filterA();
tl.add(Flip.from(s, Object.assign({}, opts, { absolute: true, onLeave: (els) => gsap.to(els, { opacity: 0, scale: 0, duration: 0.6 }) })), 1.0);
tl.progress(0);
} else {
if (mode === "static1" || mode === "static2") sortAB();
if (mode === "static2") toRow();
if (mode === "static3") filterA();
tl.to({}, { duration: 2 });
document.getElementById("root").setAttribute("data-duration", "2");
}
window.__timelines["main"] = tl;
})();
</script>
</body>
</html>
<!-- render: hyperframes render . -o reorder.mp4 --fps 24 --workers 2 --quality high --variables '{"mode":"reorder"}' -->The composition we rendered, as generated by our script. gsap.min.js and Flip.min.js sit next to it.
Method and limits
- No footage is used: the cards are a test composition we built.
- One cold run and three timed runs for the reorder case only. The probe cases were rendered once.
- GSAP is under its standard no-charge licence; read it before you use it in a commercial product (https://gsap.com/standard-license).
- Tool versions: gsap 3.15.1, HyperFrames 0.8.10. Results can change when they update.
Page checked on Nov 4, 2026.