Guida
Animare a 60 fotogrammi al secondo: cosa costa al browser e come risparmiare
Un’animazione scatta quando il browser non riesce a disegnare un fotogramma in sedici millesimi di secondo. Quali proprietà sono gratis e quali costano care, cos’è il layout thrashing e come si evita, quando serve will-change, come animare centinaia di elementi con un solo IntersectionObserver e come provare tutto su un telefono vero.
Lista o grigliaUno schermo normale si aggiorna sessanta volte al secondo. Perché un’animazione sembri fluida, il browser deve preparare ogni fotogramma in meno di sedici millisecondi e mezzo, e in quel tempo deve fare anche tutto il resto: eseguire gli script, rispondere ai clic, caricare le immagini. Quando non ce la fa, salta un fotogramma, e l’occhio se ne accorge subito come un piccolo strappo. Su un computer recente lo spazio è largo; su un telefono di fascia media, con la batteria in risparmio, è stretto. Questa guida spiega dove va il tempo e come non sprecarlo.
Come il browser disegna un fotogramma
Ogni volta che qualcosa cambia sulla pagina, il browser può dover fare fino a quattro lavori, in quest’ordine.
Stile. Calcola quali regole CSS valgono per ogni elemento.
Layout. Calcola dove sta ogni elemento e quanto è grande. Se un elemento cambia larghezza, possono spostarsi anche tutti quelli intorno, e il calcolo si allarga a mezza pagina.
Pittura. Riempie i pixel: testi, colori, ombre, bordi.
Composizione. Mette insieme i livelli già dipinti, li sposta, li ruota, li rende trasparenti, e manda il risultato allo schermo. Questo lavoro lo fa la scheda grafica, ed è velocissimo.
Il segreto delle animazioni fluide è tutto qui: animare solo le proprietà che toccano l’ultimo passo. Se un fotogramma richiede soltanto la composizione, il browser salta layout e pittura, e l’animazione resta fluida anche mentre il resto della pagina lavora.
Le proprietà gratis: transform e opacity
Due proprietà, in pratica, toccano solo la composizione: transform (spostamenti, rotazioni, scale) e opacity. Tutto il resto, se animato, costa di più. Lo stesso effetto si può quasi sempre ottenere in due modi, uno caro e uno economico.
/* caro: ogni fotogramma ricalcola l’impaginazione */
.pannello { transition: left 0.4s, width 0.4s; }
/* economico: solo composizione */
.pannello { transition: transform 0.4s; }
Spostare un elemento con left o top lo fa passare dal layout; spostarlo con translate no. Allargarlo con width sposta tutto quello che gli sta intorno; ingrandirlo con scale no. Per un fondo che si gonfia, come quello dei pulsanti a pillola, si anima scale su un livello separato dietro al testo, così il testo non si deforma e l’impaginazione resta ferma.
Il filtro blur, le ombre grandi e clip-path stanno nel mezzo: costano pittura a ogni fotogramma, ma su elementi piccoli vanno bene. Su un’immagine a tutto schermo, un blur animato è il modo più rapido per far scattare un telefono.
Il layout thrashing
C’è un errore che rallenta anche le animazioni fatte con transform: leggere e scrivere le misure della pagina in alternanza, dentro lo stesso fotogramma. Ogni volta che si legge una misura, come offsetHeight o getBoundingClientRect(), dopo aver cambiato uno stile, il browser è costretto a ricalcolare subito il layout per rispondere. In un ciclo su cento elementi diventano cento calcoli del layout invece di uno.
/* lento: legge e scrive cento volte */
schede.forEach((s) => {
const h = s.offsetHeight;
s.style.transform = `translateY(${h * 0.1}px)`;
});
/* veloce: prima tutte le letture, poi tutte le scritture */
const altezze = schede.map((s) => s.offsetHeight);
schede.forEach((s, i) => {
s.style.transform = `translateY(${altezze[i] * 0.1}px)`;
});
La regola è raggruppare: prima si misura tutto, poi si cambia tutto. GSAP lo fa già al suo interno per le animazioni che gestisce, ed è uno dei motivi per cui è più veloce di molti script scritti a mano. Il problema torna quando si mescolano le sue animazioni con letture fatte in un onUpdate o in un gestore dello scroll.
Gli eventi che arrivano troppo spesso
Lo scroll e il movimento del puntatore possono generare eventi più di sessanta volte al secondo. Fare lavoro pesante dentro questi gestori è la causa più comune di scatti. Le soluzioni sono due. Per lo scroll, si lascia il calcolo a ScrollTrigger o a un IntersectionObserver, che lavorano nel momento giusto del fotogramma. Per il puntatore, si salva la posizione nel gestore e si disegna una volta per fotogramma.
let x = 0, y = 0;
window.addEventListener('pointermove', (e) => { x = e.clientX; y = e.clientY; }, { passive: true });
gsap.ticker.add(() => {
gsap.set('.cursore', { x, y });
});
Il gestore costa quasi niente, e il disegno avviene nel ticker di GSAP, una volta sola per fotogramma. Ancora meglio, gsap.quickTo crea una funzione già ottimizzata per aggiornare la stessa proprietà molte volte di seguito, senza creare un’animazione nuova a ogni chiamata.
will-change: quando aiuta e quando no
will-change: transform dice al browser che un elemento sta per muoversi, e il browser lo mette in anticipo su un livello suo, pronto per la composizione. Usato bene toglie il piccolo scatto all’inizio di un’animazione. Usato male fa danni: ogni livello occupa memoria della scheda grafica, e cento elementi con will-change possono esaurirla su un telefono, con il risultato opposto.
Le regole pratiche sono tre. Si mette solo sugli elementi che si animano davvero e spesso, come una galleria che scorre o un cursore personalizzato. Si toglie quando l’animazione è finita, se non deve ripartire. Non si mette mai su un selettore generico che prende tutta la pagina. GSAP, durante le animazioni di transform, usa già trasformazioni 3D che portano l’elemento su un livello suo: nella maggior parte dei casi non serve aggiungere niente.
Le liste lunghe: un solo osservatore invece di cento trigger
Il caso che ci ha insegnato di più è stata la pagina della libreria di Animorio, con più di trecento schede in una sola pagina, ognuna con una piccola animazione d’entrata. All’inizio ogni scheda aveva la sua timeline con il suo ScrollTrigger, creati tutti all’apertura. Su un telefono questo voleva dire secondi di lavoro bloccante prima che la pagina rispondesse: trecento animazioni create e trecento trigger da misurare, e da rimisurare a ogni cambio di dimensione.
La soluzione è stata cambiare il momento in cui l’animazione nasce. Lo stato di partenza lo tiene il CSS, e un solo IntersectionObserver guarda tutte le schede; quando una arriva nello schermo, l’osservatore crea la sua animazione e smette di guardarla.
const osserva = new IntersectionObserver((voci) => {
voci.forEach((v) => {
if (!v.isIntersecting && v.boundingClientRect.top >= 0) return;
osserva.unobserve(v.target);
gsap.fromTo(v.target.querySelector('.foto'), { scale: 1.2 }, { scale: 1, duration: 1.2, ease: 'expo.out' });
v.target.classList.add('vista');
});
}, { rootMargin: '0px 0px -12% 0px' });
document.querySelectorAll('.scheda').forEach((s) => osserva.observe(s));
Due dettagli contano. Il rootMargin negativo in basso fa partire l’animazione quando la scheda è già un po’ dentro lo schermo, come lo start di ScrollTrigger. E il controllo su boundingClientRect.top apre subito le schede che stanno sopra lo schermo, cosa che succede quando la pagina si riapre già scrollata con il tasto indietro. Il lavoro bloccante all’apertura è sceso da 3,9 secondi a 0,2, sullo stesso telefono.
Gli elenchi che si riordinano
Quando molti elementi cambiano posto insieme, per un filtro o un cambio di vista, calcolare a mano dove va ognuno è lento e fragile. Il plugin Flip di GSAP misura tutte le posizioni prima del cambio, lascia che il CSS faccia il nuovo layout e poi anima ogni elemento con transform dalla vecchia posizione alla nuova. Il layout viene calcolato due volte in tutto, non sessanta volte al secondo.
const stato = Flip.getState('.vino');
contenitore.classList.toggle('griglia');
Flip.from(stato, { duration: 0.7, ease: 'power3.inOut', stagger: 0.02 });
In lista o griglia le bottiglie di una carta dei vini volano libere al loro posto nuovo, crescendo o rimpicciolendo, quando si cambia vista: è esattamente questa tecnica.
Gli elementi che si muovono sempre
Le fasce che scorrono senza fine, come i loghi dei clienti, sono un caso a parte: non finiscono mai, quindi devono costare il minimo possibile. Si anima una sola fila con transform, duplicando il contenuto per chiudere il giro, e si ferma tutto quando la fascia esce dallo schermo o quando la scheda del browser non è visibile. Nei loghi dei clienti che scorrono le due file rallentano fino a fermarsi al passaggio del puntatore, con un’inerzia morbida invece di uno stop secco.
const giro = gsap.to('.fila', { xPercent: -50, duration: 30, ease: 'none', repeat: -1 });
new IntersectionObserver(([v]) => {
v.isIntersecting ? giro.play() : giro.pause();
}).observe(document.querySelector('.fascia'));
Provare su un telefono vero
Il computer su cui si sviluppa è quasi sempre molto più veloce dei telefoni di chi visita il sito. Due strumenti aiutano. Negli strumenti per sviluppatori di Chrome, la scheda Prestazioni permette di rallentare il processore di quattro o sei volte: se l’animazione scatta lì, scatterà su molti telefoni. La stessa scheda, registrando un’animazione, mostra in rosso i fotogrammi persi e, sopra ognuno, se il tempo è andato in script, layout o pittura. E conviene sempre una prova su un telefono vero, collegato al computer: il calore, il risparmio energetico e lo schermo a 120 Hz cambiano molto le cose.
Le animazioni a scorrimento e in 3D, come la galleria di foto sul cilindro che gira allo scroll o le carte che si impilano, sono quelle da provare con più attenzione: muovono elementi grandi e spesso con immagini. Tenere le immagini della misura giusta, non più grandi di quanto si vedono, è da solo uno dei miglioramenti più efficaci.
In sintesi
Animare transform e opacity, non le misure. Leggere tutte le misure prima di scrivere. Non fare lavoro pesante negli eventi di scroll e del puntatore. Usare will-change con parsimonia. Per gli elenchi lunghi un solo osservatore, per i riordini Flip, per i movimenti continui una pausa quando non si vedono. E provare tutto su un telefono lento, prima di pubblicarlo. Ogni pezzo della libreria di Animorio è pensato con queste regole, e il codice che si copia le porta con sé.
Da provare nella libreria
I pezzi citati nella guida, con la demo dal vivo, le manopole e il codice.





