2 sezioni tecniche sono chiuse qui sotto. Apri quelle che ti incuriosiscono, oppure tutte.

In breve

Prima di scegliere come costruire siti web volevo numeri veri, non opinioni. Così lo stesso piccolo blog è stato costruito con 13 tecnologie diverse, dall’HTML puro a WordPress, e ogni versione è stata misurata allo stesso modo su due macchine noleggiate su Google Cloud.

Il risultato più chiaro: quando le pagine sono generate in anticipo (pregenerate), conta pochissimo quale framework le abbia prodotte. Tutte quelle versioni servivano circa 17.000 pagine al secondo da un piccolo server a due core. Quello che cambia è quanto codice deve scaricare ed eseguire il telefono del visitatore prima che la pagina risponda: da quasi nulla con Astro a 140 KB con Next.js.

Quando il server costruisce ogni pagina a ogni richiesta, le differenze sono grandi: sulla stessa macchina Go serviva 3.427 pagine al secondo, WordPress 50 e Ghost 42. Una cache delle pagine riporta WordPress e Ghost oltre le 12.000. Il progetto, il codice e tutti i numeri grezzi sono pubblici; le sezioni tecniche qui sotto sono chiuse.

Tutto il benchmark in 104 secondi. Il video è in inglese, con sottotitoli in inglese; ogni numero sullo schermo viene dagli stessi risultati dei grafici qui sotto.
Grafico a barre delle richieste al secondo con ogni pagina generata a ogni richiesta su un server da 2 vCPU: Go 3.427, Astro 1.631, SvelteKit 979, React Router 487, Nuxt 288, Qwik City 214, Laravel Octane 208, Next.js 168, Laravel PHP-FPM 144, Angular 123, WordPress 50, Ghost 42; ogni versione statica serve da 16.600 a 18.300.
Pagine di articolo al secondo con ogni pagina generata a ogni richiesta, senza cache, su una VM da 2 vCPU. La linea grigia indica dove arriva ogni versione pregenerata. Il grafico è in inglese, come il repository.

Il benchmark su GitHub ↗Conclusioni: cosa dicono i numeri (in inglese) ↗

Perché l’ho misurato

Questo sito è costruito con Nuxt e pregenerato su Cloudflare Pages. Pianificando i prossimi progetti volevo confrontarlo con le alternative che si sentono più spesso: Next.js, WordPress e l’HTML puro servito da nginx. I confronti che si trovano online misurano di solito una cosa sola, quasi sempre le richieste al secondo su una pagina “hello world”, su hardware che nessuno può riprodurre.

Ho aggiunto i framework che tornano sempre nelle stesse discussioni: Astro, SvelteKit, React Router (il successore di Remix), Angular e Qwik City, più Hugo come generatore di siti statici classico, Go con la sua libreria standard, htmx sopra Go, Laravel e Ghost come altra piattaforma di blogging diffusa. La velocità era solo una delle domande. Volevo anche capire quanto è difficile mantenerli, cosa offrono per analytics e monitoraggio, come si comportano quando qualcosa va storto e quanto lavoro serve per costruire la stessa cosa.

Un blog, costruito 15 volte

Ogni versione costruisce lo stesso sito, chiamato Field Notes: una home, un indice del blog con ricerca e filtri per tag che funzionano senza ricaricare la pagina, 40 articoli con blocchi di codice e immagini, una pagina “chi sono”, una pagina 404, un feed RSS e una sitemap. Contenuti, foglio di stile e immagini sono condivisi, quindi cambia solo la tecnologia.

Una versione scritta a mano in HTML fa da riferimento. Un verificatore confronta ogni altra versione con quella: stesso markup, link, titoli e codici di stato, più un browser vero che scrive nella ricerca, clicca i filtri per tag e attiva il tema scuro. Una versione viene misurata solo dopo aver superato tutti i 1.214 controlli (1.257 per le versioni che filtrano anche sul server).

Le implementazioni sono state scritte da agenti di programmazione AI con le stesse istruzioni, uno per framework, e ognuno ha annotato versioni, decisioni e ogni punto in cui il framework ha opposto resistenza. Il confronto è così coerente, ma i numeri sull’impegno descrivono quanto è stato difficile ottenere esattamente il risultato richiesto, non quanto ci metterebbe una persona.

L’indice del blog Field Notes con il tag Go selezionato: una casella di ricerca, undici pulsanti dei tag con Go evidenziato, la scritta Showing 13 of 40 posts e tre schede di articoli con copertine astratte.
Il sito di riferimento, filtrato per tag. Tutte le 24 versioni generano questa pagina con lo stesso markup.

Il contratto del sito (in inglese) ↗Il verificatore di conformità ↗

Due macchine virtuali nella stessa zona Google Cloud di Milano. Il bersaglio è una n2-standard-2, due vCPU e 8 GB, cioè un piccolo VPS, e fa girare solo la versione in prova, in Docker. Una n2-standard-4 separata fa girare il generatore di carico, il browser e lo strumento di misura, che comanda il bersaglio via SSH. Carico e bersaglio non condividono mai l’hardware.

I framework che sanno fare entrambe le cose vengono misurati due volte. In modalità statica ogni pagina è pregenerata e i file sono serviti con la stessa configurazione nginx. In modalità server ogni pagina è generata a ogni richiesta senza alcuna cache, il caso peggiore scelto apposta: misura il motore di rendering. WordPress e Ghost hanno anche una modalità con cache, una cache nginx davanti, perché è così che vengono usati di solito.

Ogni versione passa poi per le stesse fasi. Una build Docker a freddo, cronometrata. Carico con oha a 10 e 100 connessioni simultanee su cinque percorsi, registrando throughput, latenza, CPU e memoria dai cgroup dei container. Lighthouse su tre pagine. Un test Playwright con il profilo di un telefono rallentato, che misura quando il filtro per tag inizia a funzionare. Prove di robustezza, sovraccarico, tre minuti di carico continuo, un crash e, per i CMS, il database spento. Infine il conteggio delle dipendenze e una scansione delle vulnerabilità con Trivy su ogni immagine.

bench/cloud/create-vms.sh          # due VM, Docker, lo strumento di misura, SSH tra le due
source bench/cloud/env.sh <ip-del-bersaglio>
bench/run-all.sh                    # build, conformità, carico, lighthouse, interazione, robustezza, codice
node bench/report.mjs               # rigenera docs/results.md

Metodologia (in inglese) ↗oha, il generatore di carico ↗Tipi di macchina N2 di Google Cloud ↗

La prima misurazione completa è girata sul mio server di casa, e verificandola ho trovato quattro problemi nel mio stesso strumento. Il processore ha quattro core con due thread ciascuno, e la CPU logica 0 condivide un core fisico con la CPU 4: il generatore di carico sulle CPU da 4 a 7 competeva con il bersaglio sulle 0 e 1 attraverso l’hyperthreading. Docker elaborava decine di migliaia di righe di log al secondo e occupava quasi un core intero, sul core che preferiva. Il generatore di carico chiedeva la compressione gzip, quindi i framework che comprimono per impostazione predefinita facevano un lavoro in più che gli altri saltavano. E due prove erano sbagliate: un presunto XSS riflesso in Astro era un tag script dentro un attributo tra virgolette, che i browser non eseguono mai, e una cache delle pagine faceva sembrare sano un WordPress appena andato in crash.

Ogni correzione è nel repository. Poi il riavvio notturno di un altro servizio sulla stessa macchina ha interrotto la misurazione corretta. È lì che ho spostato le misure su due macchine cloud dedicate: un benchmark che condivide l’hardware con tutto il resto misura anche tutto il resto.

Servire le pagine

Pregenerate, tutte le versioni hanno servito la pagina di articolo tra 16.600 e 18.300 richieste al secondo con 3,4 MB di memoria sul server. Il framework qui non conta, perché nginx serve dei file. L’unica eccezione visibile è il peso delle pagine: Next.js e Qwik incorporano nell’HTML i dati per il client, quindi il loro indice del blog pesa 109 KB e 147 KB contro i 45 KB del riferimento, e quelle due pagine hanno servito solo 10.900 e 7.900 richieste al secondo.

Generata a ogni richiesta, una pagina di articolo costa da mezzo millisecondo a 37 millisecondi di CPU: Go 0,54 ms, Astro 0,71, SvelteKit 1,3, React Router 2,4, Nuxt 5,1, Qwik 6,1, Next.js 8,0, Laravel su Octane 9,2, Angular 11, Laravel su PHP-FPM 13, Ghost 30 e WordPress 37,5. Le pagine elenco costano da due a sette volte di più. I server Node, inoltre, usavano solo da 1,1 a 1,5 delle due vCPU, mentre Go e PHP le usavano quasi entrambe.

Tutti i risultati di carico (in inglese) ↗

Cosa scarica il visitatore

Le parti interattive sono le stesse ovunque: l’interruttore del tema scuro e il filtro del blog. Ogni framework le ha costruite a modo suo, e la quantità di codice che il browser riceve per l’indice del blog cambia molto:

Su un telefono rallentato il filtro inizia a rispondere dopo 0,55 secondi quando non c’è un framework lato client, Astro compreso, dopo circa un secondo con Qwik e htmx, 1,1 con SvelteKit, 1,4 con Angular e Nuxt, e da 1,6 a 1,8 con React Router e Next.js. Lighthouse ha dato a ogni pagina tra 93 e 100, quindi in un unico punteggio queste differenze passano facilmente inosservate.

  • Astro: nessun file di script, 1,5 KB di script inline.
  • HTML puro, Hugo, Go, Laravel, WordPress e Ghost (uno script condiviso in JavaScript semplice): 1,2 KB.
  • Go con htmx: 18 KB.
  • SvelteKit: 44 KB, più 19 KB inline.
  • Qwik City: 47 KB, più 63 KB di stato serializzato inline.
  • Nuxt: 86 KB. Angular: 97 KB.
  • React Router: 119 KB, più 23 KB inline.
  • Next.js: 140 KB, più 74 KB di dati inline.
Grafico a dispersione del JavaScript scaricato sull’indice del blog rispetto al tempo prima che il filtro funzioni su un telefono rallentato: HTML puro e Astro vicino a 0 KB e 550 ms, Go con htmx 18 KB e 1.046 ms, SvelteKit 44 KB e 1.118 ms, Qwik 47 KB e 976 ms, Nuxt 86 KB e 1.462 ms, Angular 97 KB e 1.419 ms, React Router 119 KB e 1.642 ms, Next.js 140 KB e 1.831 ms.
File JavaScript dell’indice del blog rispetto al tempo prima che il filtro per tag funzioni, con il profilo di un telefono con CPU 4 volte più lenta e connessione a 1,6 Mbps. Per ogni tecnologia, la versione statica quando esiste.

Sotto sforzo

Con 1.000 connessioni simultanee, le versioni pregenerate, Go, Laravel su Octane e WordPress e Ghost con cache hanno completato ogni richiesta entro dieci secondi. Le versioni Node generate sul server ne hanno completate dal 58 al 94 per cento, WordPress e Ghost senza cache il 29 per cento. Quei fallimenti sono soprattutto visitatori che rinunciano, non crash: il server semplicemente non riusciva a stare al passo.

Sono emerse alcune lacune precise. Angular e Qwik in modalità server hanno risposto a un indirizzo malformato con un errore del server. Astro, Angular e Qwik in modalità server, e Ghost senza cache, hanno impiegato tutti i dieci secondi che Docker concede per fermarsi, segno che i loro server ignorano il segnale di arresto. Con il database spento, WordPress senza cache restituiva errori, mentre WordPress e Ghost con cache continuavano a servire le pagine dalla cache. Nessuna versione ha riflesso lo script iniettato o esposto un file di configurazione o di codice.

Risultati di robustezza (in inglese) ↗

Oltre la velocità

Il resto del confronto viene da ricerche con una fonte per ogni affermazione, e da quello che è successo costruendo lo stesso sito ovunque:

  • Manutenzione: Go garantisce la compatibilità e non ha bisogno di dipendenze; Angular e Laravel pubblicano una versione all’anno con due anni di correzioni. La prossima versione principale di Qwik è rimasta in beta per circa 16 mesi, e l’unica politica di Ghost è usare l’ultima versione.
  • Storico di sicurezza: Next.js ha avuto 66 avvisi in due anni, sette critici; Ghost 70 solo nel 2026, tra cui una SQL injection senza autenticazione. L’output pregenerato espone solo nginx.
  • Monitoraggio: Laravel ha strumenti propri (Pulse, Telescope, Nightwatch), Go include profiling e log strutturati, Next.js e SvelteKit hanno il tracing integrato.
  • Analytics: nulla è davvero incluso. Ghost ci va più vicino con analytics native, che chi lo ospita da sé ottiene solo con un servizio aggiuntivo; altrove è un plugin o un tag script.
  • Impegno: Astro non ha richiesto soluzioni di ripiego e ha avuto meno codice tra i framework JavaScript. Next.js ha richiesto una riscrittura per restituire una vera pagina 404, Nuxt un’opzione sperimentale non documentata e Ghost una serie di riscritture nginx.
  • Modifica dei contenuti: solo WordPress e Ghost danno a chi non programma un editor pronto all’uso.

Note di ricerca per tecnologia (in inglese) ↗Valutazioni e criteri per tecnologia (in inglese) ↗

Cosa ne ricavo

Per un sito di contenuti come questo, pregenerare conta più del framework. Tutte le versioni pregenerate servivano le pagine allo stesso modo, quindi la scelta dipende da quanto JavaScript si è disposti a inviare, da quanto è piacevole lavorare con il framework e da chi modifica i contenuti. Nuxt, pregenerato su Cloudflare Pages, regge bene; Astro invierebbe meno JavaScript per le stesse pagine.

Quando le pagine vanno costruite a ogni richiesta su un piccolo server, Go, Astro e SvelteKit lasciano molto più margine degli altri. Quando a modificare il sito sono persone che non scrivono codice, WordPress o Ghost hanno senso, ma solo dietro una cache delle pagine: senza, servivano 50 e 42 pagine al secondo e sotto carico non completavano la maggior parte delle richieste.

Limiti

Ogni configurazione è stata misurata una volta (Lighthouse tre volte, il test sul telefono cinque), su macchine cloud che condividono l’hardware con altri clienti; versioni nginx identiche variavano di circa il dieci per cento, quindi le differenze più piccole sono rumore. Il sito è piccolo e fatto soprattutto di contenuti, e la modalità server è senza cache apposta, quindi un uso reale dei framework Node si avvicinerebbe ai numeri delle versioni pregenerate. Il repository contiene tutto il necessario per ripetere la prova, compresi gli script che creano ed eliminano le due macchine.