Prestazioni, portabilità e affidabilità non dipendono solo dai kernel: il vero lavoro è nelle “giunzioni” tra JS, Wasm, WebGPU e persistenza.
Perché far girare un LLM nel browser
Eseguire modelli direttamente in una pagina web sta diventando una scelta architetturale concreta, non più solo una demo. I motivi sono pragmatici:
- Distribuzione immediata: una web app è il modo più semplice per “spedire” un modello. Nessuna installazione.
- Dati sul dispositivo: prompt e contenuti restano localmente; utile per privacy e contesti offline.
- Target GPU unico: per chi sviluppa, WebGPU evita la frammentazione tipica di CUDA/Metal/Vulkan.
- Portabilità crescente: WebGPU ormai copre più browser e piattaforme, riducendo l’attrito di compatibilità.
WebLLM si inserisce qui come motore open source per far girare LLM in-page, usando la GPU dell’utente via WebGPU, con un’API “stile OpenAI” lato applicazione.
WebLLM 2.0: la svolta sta nelle boundary, non solo nei kernel
Con l’evoluzione dei modelli (multimodali, tool calling, stati ibridi) la complessità non cresce linearmente nel compute, ma soprattutto in ciò che “circonda” il modello:
- download e caricamento di artefatti grandi
- passaggi di controllo e dati tra JavaScript, WebAssembly e WebGPU
- adattamento a device e browser con capacità diverse
- collegamento tra output del modello e codice applicativo (tool/function calling)
- gestione dello stato in un ambiente dove una pagina può ricaricarsi o essere terminata in qualsiasi momento
In altre parole: le prestazioni e l’affidabilità dipendono quanto dai kernel, quanto da come attraversi le interfacce.
Architettura: dove sono davvero i “punti critici”
In sintesi, una pipeline tipica è:
-
Compilazione ahead-of-time (TVM/MLC): da un modello (es. Hugging Face) a un package con:
- pesi
- kernel WGSL
- libreria Wasm
- manifest
- Download e cache del package nel browser.
- L’app chiama il motore tramite Web Worker.
- Il worker guida il runtime (FFI verso TVM/Wasm), che a sua volta guida WebGPU.
Le boundary principali diventano:
- Esecuzione: JS ↔ Wasm ↔ WebGPU (latenze, sincronizzazioni, submit)
- Interfacce: modello ↔ runtime ↔ device e output ↔ app
- Storage: caching degli artefatti e persistenza dello stato di generazione
1) Esecuzione: ridurre idle e sincronizzazioni tra CPU e GPU
Un pattern tipico nell’inferenza token-by-token è che non “vince” chi ha il kernel più veloce, ma chi riduce i buchi tra un passo e l’altro.
Profilazione end-to-end (non solo GPU)
Un approccio efficace è tracciare una timeline unica che includa:
- main thread
- decode worker
- I/O worker
- bridge Wasm/FFI
- submission WebGPU
- timestamp query GPU
- readback
Questo tipo di traccia rende visibile un problema classico: GPU veloce, ma spesso inattiva perché la pipeline attende il “ritorno” di informazioni minime (ad esempio il token campionato).
Readback ring: mantenere il token sulla GPU e pipeline più profonda
Quando il campionamento viene spostato sulla GPU, la sincronizzazione residua spesso diventa il readback verso CPU. Se ogni readback costringe a “aspettare il submit successivo”, la GPU finisce per stare ferma.
La soluzione introdotta è una sorta di ring/buffer di readback che permette di:
- mantenere il token campionato sul lato GPU
- alimentare direttamente il passo successivo
- avere più submission in volo contemporaneamente
- sovrapporre attese di readback con forward/sampling
C’è però un compromesso fondamentale per un’app web: interattività e controllo. Per questo conviene:
- limitare il numero di submission accodate
- prevedere punti di commit
- gestire correttamente rollback/stop token (per preservare la correttezza della sequenza e dello stato KV)
WebGPU “immediates”: meno traffico per gli argomenti dei kernel
Un altro costo nascosto è l’invio continuo di piccoli scalari (dimensioni, stride, offset) tramite uniform buffer: aggiornamenti, mapping, bind… tutto overhead.
Con il supporto diffuso alle immediates (argomenti immediati), il runtime può:
- riscrivere lo shader
- impostare direttamente i byte nella compute pass
Risultato: meno round-trip e un guadagno misurabile in token/sec, soprattutto quando la pipeline è già ben ottimizzata e ogni micro-costo diventa visibile.
Impatto pratico
L’effetto combinato di submission più “monolitiche”, sovrapposizione CPU/GPU, ring di readback e riduzione dell’overhead sugli argomenti porta WebLLM molto vicino a prestazioni native comparabili, almeno rispetto a baseline reali di compilatori ML (non necessariamente “il miglior kernel scritto a mano”).
In parallelo, un’area critica è la memoria di picco durante il load: evitare copie inutili (ad esempio su shard di tensori) può ridurre drasticamente i picchi e migliorare stabilità su device meno generosi.
2) Interfacce: rendere esplicite capacità del device e compatibilità degli artefatti
Dire “WebGPU è portabile” è vero a grandi linee, ma nella pratica:
- limiti e feature variano per device, browser e versione
- persino sullo stesso device possono cambiare dettagli (numero di buffer, limiti di binding, ecc.)
Se carichi un artefatto compilato “quasi compatibile”, puoi ottenere il peggio: sembra funzionare, poi fallisce tardi o produce output plausibili ma errati.
Build multiple e selezione prima del download
Un passo importante è permettere al package del modello di includere più build, ciascuna con:
- requisiti precisi (feature, limiti, dimensioni binding…)
- hash di integrità
Il runtime può scegliere la prima build eseguibile sul device prima di scaricare pesi e asset pesanti. È un miglioramento enorme lato UX e costi di rete.
Manifest: contratto esplicito tra package e runtime
Il manifest diventa un vero “contratto” che collega:
- task supportati
- processor di input
- schema dei pesi
- token/prompt template
- entry point ed export del runtime
- adattatori e tipo di stato
La compatibilità può essere verificata via hash/schema: se non combacia, meglio errore esplicito che generazioni silenziosamente sbagliate.
Multimodale senza JS ad-hoc
Un effetto collaterale molto interessante: con prompt template e placeholder definiti nel manifest (prefix/placeholder/suffix token id), puoi unificare la pipeline multimodale.
Per i modelli vision, questo consente di eliminare grandi porzioni di codice JavaScript “specifico per modello” nel preprocessing: meno rami, meno bug, meno regressioni.
Output strutturato e tool calling: oltre il “JSON mode”
Nel mondo agentico, una risposta può alternare testo libero e chiamate a tool. Un semplice “rispondi con JSON valido” non basta.
Un approccio robusto è usare tag strutturali e una grammatica (es. stile XGrammar) per:
- delimitare in modo non ambiguo quando iniziano/finiscono function name e arguments
- ottenere un vincolo token-level (bitmask) molto veloce
- compilare e cache-are la grammatica una volta
Per chi costruisce UI e agent nel browser, questo riduce drasticamente:
- parsing fragile
- prompt engineering difensivo
- casi limite in streaming
3) Storage: cache degli artefatti e “resumable generation” dopo reload
OPFS come cache robusta
Oltre a Cache API e IndexedDB, OPFS (Origin Private File System) offre un modello interessante: puoi trattarlo come una cache “a record” (byte count, tipo, payload) e:
- validare record malformati
- avere performance e controlli più prevedibili su file grandi
Cross-origin cache (riuso degli artefatti)
Quando più origin devono condividere gli stessi modelli, ri-scaricare ogni volta è uno spreco. Una soluzione è abilitare un riuso cross-origin tramite meccanismi dedicati (ad esempio con estensione), mantenendo hash di integrità per evitare asset errati.
Riprendere una generazione dopo un reload
Il browser è un ambiente dove reload, crash o terminazioni (anche indotte da service worker) sono eventi normali. Senza supporto specifico, una generazione lunga viene persa.
La modalità resumable affronta il problema salvando in OPFS:
- token generati (journal append-only)
- stato RNG
- checksum di coerenza
Per ridurre il costo di ripresa, entra in gioco il concetto chiave: checkpoint del KV cache ogni N token.
In caso di ripartenza:
- ricarichi il checkpoint KV
- riproduci solo i token non coperti dal checkpoint
- ripristini RNG coerentemente
- riprendi lo streaming
Il risultato è una ripresa più veloce rispetto al replay completo, con output consistente.
Implicazioni pratiche per chi fa frontend
WebLLM 2.0 è interessante non solo per “far girare un modello”, ma perché mostra una direzione chiara per l’AI on-device in web app:
- La performance è un problema di pipeline: submit, readback, batching, overlap contano quanto i kernel.
- La portabilità richiede contratti: manifest, requisiti device, build multiple e hash evitano comportamenti ambigui.
- L’affidabilità passa dallo storage: OPFS e checkpoint trasformano una demo in un’esperienza utente robusta.
Sintesi
Portare LLM e modelli multimodali nel browser significa progettare bene le “cuciture” tra esecuzione, interfacce e persistenza. WebLLM 2.0 dimostra che, una volta ridotti overhead e sincronizzazioni, resi espliciti i contratti di compatibilità e introdotta la ripresa dello stato, l’AI in pagina diventa una scelta credibile per prodotti reali: più privacy, più offline, meno frizione di distribuzione e un percorso tecnico sempre più maturo.
Articolo originale: https://frontendfacile.it/blog/webllm-2-0-nel-browser-come-si-ingegnerizza-l-ai-tra-esecuzione-interfacce-e-sto
Top comments (0)