transform
Composite onlyMove, scale and rotate on the GPU without touching layout or paint. The default choice for anything tied to scroll.
Every specimen below runs live on this page. Each one names the driver behind it, the properties it animates, and whether it is triggered once or scrubbed with your scroll. The pill at the bottom shows the current progress value p.
Tiles start faded and offset, then settle when they cross into view. Scroll back up past them and they reset, so every pass replays the entrance with a 70 ms stagger.
translateY(56px) → 0translateX(-70px) → 0scale(.72) → 1blur(14px) → 0rotate(-9deg) → 0inset(0 88% 0 0) → 0rotateX(70deg) → 0translateX(70px) → 0Each layer moves at a speed set by its depth value. Negative depth drifts against the scroll and reads as far away. Values above 1 outrun the page and read as close to you.
The paragraph stays pinned while you read. Each word owns a slice of the scroll range and brightens as you move through it.
Scroll is the one input every visitor already uses. Tie motion to it and the [reader sets the pace.] They can scrub forward, scrub back, or stop anywhere, and the animation never runs ahead of the reading.
Numbers tween from zero with an exponential ease-out when the row enters view. The figures are the frame budgets every scroll effect on this page has to fit inside.
The refresh rate most displays target.
Time for one frame at 60 Hz, including the browser's own work.
High-refresh phones and laptops double the frame rate.
What's left per frame at 120 Hz. Read once, then write.
Vertical scroll drives a sideways track. Every card plots the same progress value through a different easing curve, so you can compare them at a single point in time.
The orange dot sits at your current progress on every curve. Watch where each one is ahead of, or behind, the straight line.
Speed and lean come from how fast you scroll, not where you are. Flick the wheel hard, then stop, and watch it ease back to cruising speed. Scrolling up reverses it.
velocity 0.0 px/frame · skew 0.0°
A trail draws itself as you scroll. The line is one SVG path with its dash offset tied to progress, and the walker is placed with getPointAtLength().
Each new card slides over the last, which shrinks and dims underneath. The cards list what animating each property costs the browser, cheapest first.
Move, scale and rotate on the GPU without touching layout or paint. The default choice for anything tied to scroll.
Fades an element's layer in place. Pair it with transform and most entrance effects stay off the main thread.
Blur, brightness and saturation. Fine in small doses; large blur radii on big surfaces get expensive quickly.
Reveals and masks. Simple shapes such as circle() and inset() stay fast; complex polygons cost more.
Changing geometry moves everything after it on the page. Keep these out of scroll handlers and use transform instead.
A circular clip-path opens from the center and uncovers a second layer sitting directly on top of the first. The radius grows until it reaches the farthest corner.
Scroll maps straight onto two rotation angles of a preserve-3d box. Six faces, one transform, no 3D library.
The background interpolates between seven sky colors sampled from 05:00 to 11:00, and the sun climbs with your progress. Text flips between light and dark from the color's luminance so it stays readable.
A wavefront sweeps out from the lower-left corner across a grid of dots. Each frame, every dot is redrawn with a size set by its distance to the wave.
The word scales exponentially around the exact center of its O, so the hole grows until it fills the screen and you pass through into the next scene.
scale(1.00)The stages a browser runs to show one scrolled frame, in order. Progress is cut into six equal steps, and the rail fills continuously between them.
No JavaScript in this one. CSS animation-timeline: view() ties a plain keyframe animation to each tile's position in the viewport, and the bar below follows the whole page with scroll(root).
.tile {
animation: natIn linear both;
animation-timeline: view();
animation-range: entry 0% cover 42%;
}
.bar {
animation: grow linear both;
animation-timeline: scroll(root);
}
/* Runs off the main thread. */
A humanoid robot built from 28 rounded parts comes apart as you scroll, the way an exploded view in a repair manual does. Shells lift off first to show the battery, frame and actuators underneath, and dashed guide lines trace where each part came from. Scroll back up and it puts itself together.
The 3D library didn't load, so this specimen can't run here.
A puzzle cube scrambled with 20 random turns solves itself as you scroll. The solution is the scramble played backwards: each slice of the scroll range turns one face a quarter or half turn. Scroll up and it scrambles again.
The 3D library didn't load, so this specimen can't run here.