Cactus in una scheda del browser: Mirage, Whistle e Needle nella pagina lab
ai · 2026-11-15 · 5 min
cactus compute costruisce modelli piccoli per telefoni e wearables, e distribuisce l'intero motore come binario WebAssembly da 1,2 MB. è la prima volta che un modello di visione costa abbastanza poco da stare dentro una card del lab di questo sito: Mirage è 21,6 MB a 2 bit, Whistle sono 16,9 MB di riconoscimento vocale, Needle 3 sono 35,3 MB di tool calling. Nessun account, nessuna chiave API, nessuna richiesta che esce dalla scheda.
cosa fa la card
L'esperimento si chiama Cactus e ha una pagina sua, /cactus. Tre schede e un worker:
- Mirage legge un'immagine. Accendi la videocamera o carichi un file, e torna la descrizione della scena, gli oggetti con box e punteggio, e il testo che riesce a leggere. I box sono disegnati sopra l'anteprima, nella posizione reale.
- Whistle trasforma la voce in testo con i tempi delle parole. Registri dal microfono o carichi un audio: viene ricampionato a 16 kHz mono e trascritto.
- Needle prende le definizioni dei tool in JSON più una frase, e restituisce la chiamata che farebbe.
I numeri qui sotto vengono da quella card, non da un notebook.
perché il modello gira in un worker
L'inferenza è uno o tre secondi di CPU satura. Sul thread principale sono una pagina che smette di scorrere, un pulsante impostazioni che non si apre, un tap che finisce nel vuoto. Il worker serve anche a dare un posto al download: il modello viene letto a pezzi, l'avanzamento torna alla UI mentre arriva, e i byte finiscono in Cache Storage così la seconda visita non tocca la rete.
Il glue del motore è uno script classico che assegna un globale, quindi il worker lo importa tramite un blob. E siccome un worker non ha document.currentScript, il glue non può indovinare dove stia il .wasm: gli passi i byte invece di un URL, che è anche un giro di rete in meno.
const glue = await (await fetch(`${ENGINE}/cactus.js`)).text();
importScripts(URL.createObjectURL(new Blob([glue], { type: "text/javascript" })));
const wasm = new Uint8Array(await (await fetch(`${ENGINE}/cactus.wasm`)).arrayBuffer());
const M = await createCactus({ wasmBinary: wasm });
Da lì l'intera API sono quattro chiamate nell'header C: cactus_load prende i byte del .cact e una lunghezza, cactus_describe prende RGB impacchettato e una stringa JSON di opzioni, cactus_transcribe prende PCM float32, e cactus_init più cactus_complete coprono il tool calling. Un dettaglio che mi è costato dieci minuti: la lunghezza di cactus_load è un unsigned long long, quindi in JavaScript è un BigInt. Un numero normale lancia un'eccezione prima che qualsiasi altra cosa possa andare storta.
cosa restituisce Mirage
Una foto, quattro oggetti, una riga di testo, circa 500 byte di JSON:
{
"scene": { "setting": "roadside", "lighting": "daylight", "weather": "clear", "sky": "blue" },
"objects": [
{ "id": 2, "name": "stop sign", "bbox": [378, 237, 645, 437], "score": 0.643 },
{ "id": 3, "name": "pole", "bbox": [485, 406, 534, 984], "score": 0.555 }
],
"text": [{ "string": "ARRÉT", "bbox": [364, 296, 660, 379], "score": 0.856 }]
}
I box usano una scala 0-1000 rispetto all'immagine, quindi disegnarli è una percentuale: left: bbox[0] / 10%, e così via. Il modello emette anche le maschere di segmentazione per default; io chiedo fields: ["bbox", "score"] e le salto, perché i poligoni sono quattro volte il payload e la card non ne fa nulla.
numeri, da questo portatile
Tre esecuzioni, Chromium headless, wasm a un thread, nessuna GPU, nessun warm-up. I tempi sono solo inferenza: download e caricamento sono la barra di avanzamento, non questo numero.
| modello | pesi | primo risultato | output |
|---|---|---|---|
| Mirage | 21,6 MB | 2,9 s | descrizione, 5 oggetti, 1 riga di testo |
| Whistle | 16,9 MB | 1,1 s | trascrizione, 14 tempi di parola, 35 tok/s |
| Needle 3 | 35,3 MB | 1,5 s | una chiamata, argomenti corretti |
Una CPU desktop a 2-3 secondi per immagine non sono i 74 ms su NPU di un telefono che Cactus pubblicizza, e non ho intenzione di far finta del contrario. Quello che conta per un sito è che il lavoro sia limitato e sul thread giusto: la pagina resta a 60 fps mentre il modello macina, e la risposta arriva con un tempo misurato.
i limiti, senza giri di parole
- 74 MB se provi tutti e tre. In cache dopo la prima visita, ma resta un download vero su un telefono: per questo ogni scheda parte con niente caricato e la barra di avanzamento è esplicita.
- Cache Storage non è eterna. Un browser sotto pressione la svuota, e la visita dopo riscarica 21 MB. La card funziona comunque, solo più lenta una volta.
- Un modello in memoria alla volta. Cambiare scheda scarica i pesi precedenti, così la scheda non tiene 74 MB di heap wasm.
- Niente streaming. Questa build restituisce il JSON finito; non c'è un rendering token per token da animare. Uno spinner con un language model sarebbe teatro disonesto.
- Versioni fissate. Il motore è la release 4.1.1 e i pesi vengono dai repo Hugging Face come sono oggi. L'ABI wasm e il formato
.cactsi muovono insieme: una build non fissata si romperebbe in silenzio il giorno in cui cambia uno dei due. - Non è un prodotto. è una pagina a sé, /cactus: una demo che carica i pesi su richiesta e chiede la videocamera solo quando premi il pulsante. è nata come esperimento 18 della pagina lab e la card le stava stretta: una scatola 16:10 è la forma sbagliata per videocamera, trascrizione e pannello JSON insieme.
Pesi e motore sono Apache-2.0. Il worker, il client e la UI stanno in src/components/cactus/ se vuoi leggere tutto: meno di 500 righe, commenti compresi, che spiegano le due trappole qui sopra.
Provarlo: /cactus. Comincia dalla foto del cartello, poi punta la videocamera sulla scrivania.