Blog
CSR, SSR, streaming e isole: le forme di rendering dei framework frontend
Cover illustration: Genesis Wave by Liiga Smilshkalne
DevelopmentNuxtFrameworksPerformanceNov 9, 2026 (updated Nov 12, 2026) — 9 min read

CSR, SSR, streaming e isole: le forme di rendering dei framework frontend

Nuxt 4.5 ha portato lo streaming SSR, sperimentale. È l'occasione per mettere in fila tutte le forme di rendering, dal CSR alla resumability, e vedere quali framework offrono cosa.

Emanuele Nardi

Emanuele Nardi

Tra le novità di Nuxt 4.5, uscito a luglio, c'è un'opzione che sembra minore: experimental.ssrStreaming. Con lo streaming il server non aspetta di aver renderizzato tutta la pagina per mandarla: spedisce subito l'inizio e il resto man mano. Next.js lo fa dalla versione 13, Astro e SvelteKit da tempo, e per Nuxt era una richiesta aperta dal gennaio 2019.

Lo prendo come pretesto per mettere in fila tutte le forme di rendering che i framework frontend offrono: le sigle sono tante (CSR, SSR, SSG, ISR, PPR…) e ogni framework le combina a modo suo.

Lo stato descritto è quello al 9 novembre 2026: Nuxt 4.6, Next.js 16.4, SvelteKit 3.1, Astro 7.4. Lo streaming di Nuxt è ancora sperimentale e può cambiare.

Tre domande

Qualsiasi modalità di rendering risponde a tre domande:

  • Dove nasce l'HTML: durante la build, sul server o nel browser.
  • Quando: una volta per tutte, a ogni richiesta, oppure una volta ogni tanto.
  • Quanto JavaScript serve al browser perché la pagina risponda ai clic.

Le prime due decidono quanto aspetta l'utente prima di vedere qualcosa, e quanto sono freschi i dati che vede. La terza decide quanto aspetta prima di poterci fare qualcosa.

Le modalità di base

Lo schema mostra i quattro attori di una pagina web (build, server, CDN e browser) e cosa si passano in ciascuna modalità.

  1. Il browser riceve un HTML quasi vuoto e il bundle JavaScript
  2. Esegue il JavaScript, che chiede i dati alle API
  3. Solo allora disegna la pagina: fino a lì l’utente vede uno schermo vuoto o uno spinner
Le frecce vanno verso chi riceve. La linea tratteggiata in movimento arriva a pezzi.
  • CSR (Client-Side Rendering): il server manda un HTML vuoto e il browser costruisce tutto con JavaScript. Semplice da ospitare, ma l'utente aspetta il bundle e poi i dati, e un motore di ricerca che non esegue JavaScript vede una pagina vuota.
  • SSR (Server-Side Rendering): a ogni richiesta il server esegue i componenti e restituisce l'HTML completo. Si vede subito il contenuto, con dati sempre freschi, al prezzo di un server che lavora a ogni visita.
  • SSG (Static Site Generation): il rendering avviene una volta, durante la build. Le pagine sono file statici serviti da una CDN, velocissimi ed economici, ma i dati sono quelli della build. Questo sito è fatto così.
  • ISR (Incremental Static Regeneration) e SWR (stale-while-revalidate): pagine statiche con una scadenza. Scaduta, la copia vecchia continua a essere servita mentre il server ne prepara una nuova in background.

I meta-framework moderni non obbligano a sceglierne una: con il rendering ibrido ogni rotta ha la sua. In Nuxt bastano le routeRules:

nuxt.config.ts
export default defineNuxtConfig({
  routeRules: {
    '/': { prerender: true }, // SSG
    '/blog/**': { isr: 3600 }, // rigenerata al massimo una volta all'ora
    '/prodotti/**': { swr: 60 }, // cache di Nitro, un minuto
    '/admin/**': { ssr: false } // CSR
  }
})

Idratazione: il prezzo dell'HTML dal server

SSR e SSG producono HTML visibile, che però resta inerte finché non arriva il JavaScript: i pulsanti non fanno niente. Il browser allora scarica il codice dei componenti, li riesegue e collega gli eventi ai nodi che esistono già. Si chiama idratazione.

Il suo difetto è ripetere un lavoro: il browser rifà quello che il server ha già fatto, solo per scoprire dove attaccare i listener. Nel frattempo la pagina sembra pronta ma non risponde. Buona parte delle novità degli ultimi anni, dalle isole alla resumability, serve a ridurre questo costo; ci torno più avanti.

Streaming: l'HTML a pezzi

Nell'SSR classico il server costruisce tutta la pagina in memoria e la manda in un colpo. Se un componente aspetta un'API lenta, aspetta tutta la pagina, e il browser riceve il primo byte solo alla fine. Il tempo al primo byte (TTFB, Time To First Byte) diventa quello della query più lenta.

Con lo streaming il server manda subito l'inizio del documento: il <head>, gli stili, i link al JavaScript. Il browser comincia a scaricare le risorse e a disegnare mentre il server continua a renderizzare. Lo schema confronta un caricamento con le diverse modalità; prova a passare da un'API veloce a una lenta.

CSR650 ms · 650 ms
SSR300 ms · 700 ms
SSG, ISR in cache150 ms · 550 ms
SSR in streaming200 ms · 600 ms
attesa del primo byte HTML in arrivo download ed esecuzione del JS richiesta dei dati idratazione Le linee tratteggiate segnano, in ordine, il primo byte, il contenuto visibile e la pagina interattiva; i due numeri a destra sono gli ultimi due. In streaming il contenuto visibile è la parte prima dei dati lenti.

Con un'API veloce le differenze sono di qualche centinaio di millisecondi. Con un'API lenta l'SSR classico lascia lo schermo bianco per più di un secondo, mentre lo streaming mostra subito la struttura della pagina e ha già scaricato il JavaScript quando arrivano i dati. La pagina statica non risente di niente: i dati li ha presi durante la build.

In ordine o fuori ordine

React fa streaming fuori ordine: un componente lento dentro un <Suspense> viene sostituito da un fallback, il resto della pagina prosegue, e quando i dati arrivano il server manda l'HTML vero con un piccolo script che lo mette al posto del fallback.

Vue, e con lui Nuxt, fa streaming in ordine: l'HTML esce nell'ordine del documento, e un componente che aspetta i dati ferma il flusso in quel punto. Quello che sta prima arriva subito, quello che sta dopo aspetta. Lo stesso vale per Astro.

import { Suspense } from 'react'

export default function Page() {
  return (
    <>
      <Header />
      {/* The fallback goes out first; the comments replace it when ready */}
      <Suspense fallback={<p>Caricamento…</p>}>
        <Comments />
      </Suspense>
      <Footer />
    </>
  )
}

Nel caso di Next.js il footer arriva subito, in quello di Nuxt arriva dopo i commenti. Per avere lo stesso effetto in Vue, la parte lenta va caricata nel client (useFetch con server: false), oppure spostata dopo tutto il resto della pagina.

Lo streaming in Nuxt 4.5

Si attiva con un'opzione:

nuxt.config.ts
export default defineNuxtConfig({
  experimental: {
    ssrStreaming: true
  },
  routeRules: {
    // Pages that set status codes or cookies while rendering stay buffered
    '/checkout/**': { streaming: false }
  }
})

Ho guardato il renderer di Nuxt 4.6 per capire cosa succede a ogni richiesta.

  1. Con experimental.ssrStreaming attivo, ogni richiesta renderizzata dal server passa due controlli
  2. Se lo user agent è un bot (botRegex), la risposta resta bufferizzata, come senza streaming
  3. Lo stesso se la rotta ha una regola che vuole la pagina intera: redirect, cache o swr, isr, noScripts, ssr: false, streaming: false; e il prerender di nuxt generate non fa mai streaming
  4. Altrimenti Vue crea l’app e rende il primo pezzo; Nuxt invia la shell: head, stili, preload e script di ingresso
  5. Con il primo byte status e header sono partiti: cambiarli dopo (setResponseStatus, useCookie) non ha effetto, e in sviluppo Nuxt avvisa
  6. Il body arriva a pezzi; i tag head registrati più tardi arrivano come piccoli script
  7. Il payload chiude la risposta e il browser idrata la pagina
A sinistra la risposta in streaming, a destra quella bufferizzata di sempre.

Alcune cose da sapere prima di attivarlo:

  • Status e header partono con il primo byte. Dopo, setResponseStatus(), useCookie() o useResponseHeader() dentro un componente non arrivano più al browser: una pagina non trovata scoperta a metà rendering risponde comunque 200. In sviluppo Nuxt avvisa con un messaggio che nomina la rotta e le modifiche perse.
  • I bot ricevono la pagina intera. Di default, gli user agent che corrispondono a botRegex (Googlebot, Bingbot e altri crawler) ottengono la risposta bufferizzata. Se imposti la tua espressione, sostituisce quella predefinita invece di aggiungersi.
  • Molte rotte tornano al buffer da sole: quelle con redirect, cache o swr, isr, noScripts o ssr: false. Neanche le pagine prerenderizzate vanno in streaming, quindi un sito generato con nuxt generate, come questo, non ne trae nulla.
  • L'idratazione parte alla fine. Il payload, cioè i dati che il client usa per non ripetere le richieste, chiude la risposta. Il JavaScript si scarica in anticipo, ma la pagina diventa interattiva solo a stream finito, tutta insieme.
  • I tag <head> tardivi (un useHead chiamato dopo un await) non possono più finire nella shell: arrivano come piccoli script che aggiornano il documento. Un client senza JavaScript che non è nella lista dei bot non li vede.

Conviene sulle pagine renderizzate a ogni richiesta, con dati lenti nella parte bassa e senza logica che cambia lo status a metà. Per un sito statico o una pagina in cache non cambia niente.

Meno JavaScript: isole, Server Components, resumability

Lo streaming accelera l'arrivo dell'HTML; per accelerare il momento in cui la pagina risponde bisogna ridurre l'idratazione. Le strade sono tre, dalla più conservativa alla più radicale.

Idratazione completa: all’avvio arriva il codice di tutta la pagina. Il browser scarica ed esegue di nuovo tutti i componenti, anche quelli che non cambieranno mai, per collegare gli eventi all’HTML. Linea continua: all’avvio. Tratteggiata: più tardi, quando succede ciò che c’è scritto.
  • Isole e idratazione differita. La pagina è HTML statico con qualche "isola" interattiva, ognuna idratata da sola, magari solo quando entra nello schermo. È il modello di Astro, con le direttive client:visible e simili. Nuxt dalla 3.16 ha l'idratazione differita: il codice del componente arriva comunque, ma gira solo quando serve. Angular ha l'idratazione incrementale con @defer (hydrate on viewport).
  • Server Components. Componenti che girano solo sul server e non mandano codice al browser: è il default dell'App Router di Next.js, ogni componente .astro lo è, e in Nuxt ci sono i .server.vue, ancora sperimentali.
  • Resumability. Qwik non idrata affatto: serializza nell'HTML lo stato e i riferimenti ai gestori degli eventi, e scarica il codice di un gestore solo quando l'evento succede.

In Nuxt l'idratazione differita è una prop sul componente:

articolo.vue
<template>
  <ArticleBody :article />
  <!-- The comments hydrate only when they scroll into view -->
  <LazyCommentList
    :comments
    hydrate-on-visible
  />
</template>

C'è infine il Partial Prerendering (PPR) di Next.js, stabile dalla 16.0 con cacheComponents: una shell statica, pronta dalla build e servita dalla CDN, con i buchi dinamici riempiti in streaming nella stessa risposta. Unisce SSG e streaming, e tra i dieci framework della tabella è l'unico a offrirlo per intero; le server islands di Astro (server:defer) ci si avvicinano, ma riempiono i buchi con una richiesta separata.

Chi offre cosa

La tabella riassume dieci framework. Ogni cella si apre con un clic: c'è l'API da usare, la sfumatura e il link alla documentazione.

Framework CSRSSRSSGISR / SWRStreamingIbrido per rottaIsoleServer ComponentsPPRResumability
Nuxt4.6
Next.js16.4
SvelteKit3.1
Astro7.4
React Router8.5
Angular22
SolidStart2.2
Qwik2.0 RC
TanStack Start1.x
Analog2.9

Nuxt 4.6 · StreamingSperimentale

L’HTML parte a pezzi mentre il server renderizza, invece che tutto alla fine.

experimental.ssrStreaming

Dalla 4.5. In ordine, mai per i bot, e l’idratazione parte a stream finito.

Documentazione di Nuxt
StabileParzialeSperimentaleNo Stato al 9 novembre 2026, verificato sulla documentazione e sui changelog. Parziale vuol dire con limiti importanti, tramite un adapter o una libreria esterna, o con lo stesso effetto ma senza un’API dedicata.

Qualche osservazione:

  • CSR, SSR, SSG e rendering ibrido ci sono quasi ovunque, con qualche limite: il CSR in Astro e Qwik, il rendering per rotta in SolidStart.
  • ISR dipende molto dall'hosting. Nuxt, Next.js e Astro hanno un'API dedicata (in Nuxt isr si appoggia comunque alla CDN di Netlify o Vercel); gli altri passano da un adapter (SvelteKit con Vercel), da Nitro (SolidStart, Analog) o dagli header Cache-Control letti dalla CDN.
  • Lo streaming c'è quasi ovunque, ma Angular manda ancora l'HTML in un pezzo solo: per lo streaming serve Analog, dove è sperimentale. Nuxt ci è arrivato solo quest'anno, e in via sperimentale.
  • Next.js copre più caselle grazie ai Server Components e al PPR, al prezzo di un modello mentale più complesso: cache, confini di Suspense, componenti client e server.
  • Astro e Qwik sono specialisti. Astro è nato per le isole, Qwik per la resumability, e secondo me lo fanno meglio di chi l'ha aggiunto dopo.

Come scegliere

Il mio criterio parte dalle tre domande dell'inizio:

  1. Se il contenuto cambia di rado, SSG, eventualmente con ISR per le pagine che si aggiornano.
  2. Se i dati dipendono dalla richiesta (l'utente, il carrello, una ricerca), SSR, con lo streaming quando una parte della pagina è lenta.
  3. Se dietro un login non serve indicizzazione, il CSR resta la soluzione più semplice da ospitare.
  4. Poi, a parte, quanto JavaScript serve: per un sito di contenuti con poca interattività, le isole o l'idratazione differita danno più di qualsiasi ottimizzazione del server.

Lo streaming di Nuxt aggiunge una possibilità al punto due, e il resto del quadro resta com'è. Per le pagine con un'API lenta in fondo è un guadagno netto e quasi gratuito; per tutto il resto la cosa più veloce resta un file HTML già pronto su una CDN.

Fonti

build 631 • 009a823

© 2026 Emanuele Nardi