# unkernel: il vero kernel Linux nel browser, in WebAssembly

> Pubblicato: 2026-11-20

Cos'è unkernel, il progetto che compila il kernel Linux in WebAssembly e lo avvia nel browser in meno di un secondo: come funziona, a cosa serve, limiti.

Immagine creata con AI

Apri una pagina web e dopo circa 10 MB di download hai una shell Linux: Alpine con il suo gestore di pacchetti, un disco che resta dopo il ricaricamento, la rete, perfino uno schermo e l'audio. Nessun server dietro, niente da installare. È [unkernel](https://github.com/pithings/unkernel), un progetto open source pubblicato su GitHub a metà novembre 2026 da Pooya Parsa, lo sviluppatore che ha creato [Nitro](https://nitro.build/), il motore server di Nuxt, e le librerie UnJS. In una settimana ha superato le 580 stelle su GitHub ed è finito su [JavaScript Weekly](https://javascriptweekly.com/issues/811).

Di "Linux nel browser" se ne vedono da anni. Qui la differenza è un'altra: il kernel non è emulato, è il vero kernel Linux (la serie 7.x, oggi la 7.3.4) compilato in WebAssembly. Abbiamo letto il README, il codice e la storia dei commit per capire cosa fa davvero, cosa promette e dove si ferma.

&lt;InfoBox content="Stai valutando sandbox, demo nel browser o ambienti isolati per agenti AI nei tuoi progetti? Ti aiutiamo a capire se una tecnologia come unkernel è pronta per il tuo caso o se conviene una strada più collaudata. <a href='/contattaci'&gt;Scrivici&lt;/a&gt;." />

In questo articolo

- [Cos'è unkernel, in parole semplici](#cosè-unkernel-in-parole-semplici)
- [Perché è diverso dagli altri Linux nel browser](#perché-è-diverso-dagli-altri-linux-nel-browser)
- [Quanto è veloce](#quanto-è-veloce)
- [A cosa può servire a chi sviluppa](#a-cosa-può-servire-a-chi-sviluppa)
- [I limiti da conoscere prima di entusiasmarsi](#i-limiti-da-conoscere-prima-di-entusiasmarsi)
- [Come provarlo](#come-provarlo)
- [Domande frequenti](#domande-frequenti)

## Cos'è unkernel, in parole semplici

Un computer ha due strati. Sotto c'è il kernel, che gestisce memoria, processi, file e rete. Sopra ci sono i programmi: la shell, Python, Node, un database. unkernel tratta i due strati in modo diverso.

- **Il kernel è codice vero.** Linux viene compilato in un unico modulo WebAssembly (`unkernel.wasm`) con un'architettura nuova, `arch/wasm`, e gira alla velocità di WebAssembly. Scheduler, chiamate di sistema, ext4 e lo stack TCP/IP sono quelli di Linux, con i loro comportamenti anche nei casi limite.
- **I programmi sono emulati.** Girano su kwemu, una CPU aarch64 (ARM a 64 bit) scritta in Zig e collegata dentro il kernel. Siccome sono normali binari ARM, i pacchetti di Alpine e Debian funzionano così come sono, senza ricompilarli.

C'è anche una MMU vera, cioè la gestione della memoria con le tabelle delle pagine. Sembra un dettaglio da specialisti, ma decide cosa funziona: `fork`, `mmap`, la copia in scrittura, la memoria condivisa e i thread si comportano come su un server. Nei progetti senza MMU queste cose si rompono o vengono approssimate.

Dentro trovi file system veri (ext4, overlayfs, tmpfs, FUSE), cgroup e namespace. Secondo il README bastano per far arrivare systemd fino a `multi-user.target` su Ubuntu 26.10. Il disco di sistema è un'immagine in sola lettura con sopra le tue modifiche, salvate su un disco ext4 persistente: ricarichi la pagina e ritrovi tutto.

## Perché è diverso dagli altri Linux nel browser

Il README mette a confronto gli approcci esistenti. In breve:

| Approccio | Esempi | Kernel | Programmi |
| --- | --- | --- | --- |
| Emulare un PC intero | v86, JSLinux, container2wasm | Linux, emulato | originali, emulati |
| Reimplementare le syscall | runtime senza kernel | nessuno | originali, emulati |
| Runtime POSIX per wasm | WebContainers, Wasmer WASIX | nessuno | ricompilati per wasm o JavaScript |
| Linux senza MMU | linux-wasm, WasmLinux (LKL) | Linux, in wasm | ricompilati per wasm |
| **unkernel** | | **Linux, in wasm** | **originali aarch64, emulati** |

Emulare un PC intero è fedele ma lento, perché ogni chiamata di sistema passa da hardware finto. I runtime come [WebContainers](https://webcontainers.io/) di StackBlitz sono veloci ma coprono solo la parte di Linux che qualcuno ha riscritto, e i programmi nativi vanno ricompilati. unkernel prova a tenere il meglio dei due: il kernel vero, a velocità piena, sotto programmi che non vanno toccati.

Il pezzo che rende possibile tutto questo è [JSPI](https://v8.dev/blog/jspi) (JavaScript Promise Integration), un'estensione di WebAssembly che permette di sospendere e riprendere l'esecuzione. unkernel la usa per i cambi di contesto: il kernel ha stack veri che può mettere in pausa. Quando un programma fa una chiamata di sistema, kwemu restituisce il controllo al kernel, che la esegue come codice wasm nativo, senza un'eccezione emulata in mezzo.

L'idea non nasce dal nulla, e l'autore lo scrive: ringrazia [Kernarium](https://github.com/imxieyi/Kernarium) per l'idea di fondo, [linux-wasm](https://github.com/joelseverin/linux-wasm) di Joel Severin per il port `arch/wasm` da cui è partito, e [iSH](https://github.com/ish-app/ish) e [v86](https://github.com/copy/v86) per l'emulatore e il JIT.

## Quanto è veloce

Questi numeri sono quelli pubblicati dall'autore, misurati sotto Node tra il 14 e il 18 novembre 2026. Non li abbiamo rifatti noi.

| Operazione | Nativo | qemu-system | unkernel |
| --- | --- | --- | --- |
| `getppid` (syscall minima) | 110 ns | 1.662 ns | 172 ns |
| `read` di 64 byte | 161 ns | 2.247 ns | 172 ns |
| `fork` + `exit` + `wait` | 73 µs | 1.178 µs | 57 µs |

Le chiamate di sistema costano quasi come su un computer vero, e il fork in quel test è perfino più veloce del nativo. Il kernel arriva a `/init` in circa 70 ms e il prompt di Alpine compare 0,3 secondi dopo l'avvio di `node`, con 48 MiB di memoria.

Il calcolo puro invece è lento, e il README lo dice chiaramente. L'interprete esegue circa 250-300 milioni di istruzioni al secondo. Un JIT compila in WebAssembly il codice usato più spesso e rende i lavori reali da 1,6 a 2,3 volte più veloci: un `seq 100000 | sort -r` passa da 7,1 a 3,1 secondi. Resta comunque molto indietro rispetto a una macchina vera. `apk add python3` impiega circa 3,4 secondi.

Quindi: tutto ciò che vive nel kernel (avviare processi, leggere file, aprire connessioni) va veloce. Quello che macina CPU nei programmi no.

## A cosa può servire a chi sviluppa

Sulla pagina di prova ci sono già demo che fanno capire dove si può arrivare: Python, Node.js, Go e Rust, nginx che serve una pagina, PostgreSQL con un database di esempio, SQLite, Valkey, Docker che esegue `hello-world` sull'immagine Debian, e Claude Code, l'agente di programmazione di Anthropic, che si installa al primo avvio e lavora dentro la macchina nel browser.

Da qui le ipotesi d'uso che ci sembrano più concrete. Sono ipotesi, non casi già visti in produzione.

### Sandbox per agenti AI

È lo scenario che ci interessa di più. Un agente che scrive codice ha bisogno di eseguirlo da qualche parte, e farlo sul computer dello sviluppatore o su un server condiviso è un rischio: ne abbiamo parlato a proposito di [come testare gli agenti AI](/articoli/strategia-per-testare-gli-agenti-ai) e dei [rischi del sampling MCP](/articoli/sicurezza-mcp-sampling-rischi). Una macchina Linux che vive in una scheda del browser, con il disco nel browser e la rete che passa da un proxy controllato, è un recinto naturale. Se l'agente fa danni, si azzera il disco.

Lo stesso vale lato server, con l'SDK in Node. Qualche strumento utile per tenere d'occhio un agente c'è già:

- **cartelle in sola lettura**: con `--mount .:/work:ro` (o `readOnly: true` nell'SDK) l'agente vede i file del progetto ma non può modificarli;
- **un file system in memoria che registra tutto**: `MemoryFs` chiama `onChange` per ogni file che l'agente crea, modifica o cancella, quindi a fine lavoro sai esattamente cosa ha toccato;
- **niente rete se non serve**: la rete è spenta finché non la passi tu a `createKernel()`;
- **un tempo massimo**: la CLI accetta `--timeout` ed esce con il codice 124 se il tempo scade.

### Un nodo "esegui in sandbox" per i workflow n8n con AI

In [n8n](https://n8n.io/) gli agenti AI sono di casa: il nodo AI Agent sceglie da solo quali strumenti usare. Il problema arriva quando lo strumento deve eseguire codice. Il nodo Code è pensato per JavaScript o Python scritto da chi costruisce il workflow, non da un modello. E il nodo Execute Command lancia comandi sul server dove gira n8n, credenziali comprese: non a caso [da n8n 2.0](https://docs.n8n.io/2-0-breaking-changes) è disattivato di default.

Un'architettura possibile, che non abbiamo ancora messo in produzione ma che ci sembra la più pulita, è questa:

1. un piccolo servizio Node (serve Node 24) che usa l'SDK di unkernel con `worker: true` ed espone un endpoint HTTP, per esempio `POST /esegui` con lo script e i file da elaborare;
2. per ogni richiesta il servizio avvia un Alpine senza rete, partendo da un disco preparato una volta sola con i pacchetti che servono (Python, per esempio, va installato prima, visto che dopo la rete non c'è), monta i file in sola lettura, esegue lo script con `vm.exec()` e restituisce `stdout`, `stderr` e codice d'uscita, poi spegne la macchina;
3. in n8n, il nodo AI Agent ha tra i suoi strumenti un HTTP Request Tool che chiama quell'endpoint.

Qualche esempio concreto per un e-commerce: l'agente riceve l'export degli ordini in CSV e scrive lo script Python che calcola i prodotti più resi per categoria; prepara la conversione di un feed prodotti dal formato del fornitore a quello di un marketplace e la prova su un campione prima di applicarla; controlla un file di listini prima che venga importato in PrestaShop o in Odoo. In tutti questi casi il codice scritto dal modello gira in una macchina usa e getta, non sul server dove ci sono il database e le chiavi API.

Due avvertenze. Il calcolo in unkernel è lento, quindi va bene per file da qualche migliaio di righe, non per milioni. E l'SDK fa girare un solo kernel per thread: per servire più richieste insieme servono più worker.

### Demo e formazione senza installare niente

Un corso su Linux, Git o PostgreSQL in cui lo studente apre un link e ha già la shell. Una documentazione tecnica in cui il comando d'esempio si esegue davvero, nella pagina. Oggi per farlo servono container lato server, con i loro costi e i problemi di isolamento. Qui il calcolo lo fa il dispositivo di chi legge.

### Incorporarlo in un'applicazione

L'SDK in TypeScript è su [npm](https://www.npmjs.com/package/unkernel), non ha dipendenze ed è con licenza MIT. Con poche righe si avvia una macchina, si eseguono comandi e si leggono i risultati:

```js

const vm = await createKernel({ distro: await fetchDistro("alpine") });
const { stdout } = await vm.exec("uname", ["-a"]);
console.log(stdout);
```

L'SDK permette di montare cartelle dell'host dentro la macchina, parlare con i programmi via vsock, condividere memoria senza copie e fare richieste HTTP a un server che gira dentro la macchina con `vm.fetch()`. Lo stesso file del kernel gira in Node e nel browser, anche in un Web Worker.

### Test e script

Da terminale, `npx unkernel` avvia Alpine. Può scrivere input a tempo, fermarsi dopo un timeout e restituire un codice d'uscita diverso per spegnimento, kernel panic o errore. Per chi deve provare uno script su un Linux pulito, senza Docker installato, è comodo.

## I limiti da conoscere prima di entusiasmarsi

- **È giovanissimo.** Il repository è stato creato il 12 novembre 2026, la storia pubblica dei commit parte dal 15 e la versione 0.2.0 è del 19. Lo stesso giorno l'autore ha tolto la CPU riscv64 con cui il progetto era nato e l'ha sostituita con aarch64. Le API possono cambiare da un giorno all'altro e tutti i commit, finora, sono di una sola persona.
- **La rete è parziale.** Niente IPv6, niente UDP oltre a DHCP e DNS, nessuna connessione in ingresso. Nel browser si esce verso Internet solo tramite un proxy Wisp, perché le pagine web non possono aprire socket TCP.
- **Niente debug classico.** `strace` e `gdb` non funzionano, e manca seccomp.
- **Il calcolo è lento**, come detto sopra. Compilare un progetto grande o fare elaborazioni pesanti non è il suo mestiere.
- **Serve un browser recente con JSPI**: Chrome ed Edge dalla 137, Firefox dalla 153, Safari dalla 27. Sui browser più vecchi non parte.
- **Licenze da leggere.** SDK e pagina sono MIT, ma il pacchetto contiene un kernel GPL-2.0 e le immagini delle distribuzioni hanno le licenze dei loro pacchetti. Chi lo distribuisce dentro un prodotto commerciale deve tenerne conto.
- Un errore grave del kernel (una trap wasm) chiude la sessione.

## Come provarlo

Il modo più rapido è aprire [unkernel.dev](https://unkernel.dev/). Dopo il download compare la shell. Puoi installare pacchetti con `apk add`, e se scrivi un comando che manca, per esempio `htop`, il pacchetto viene installato da solo. La pagina accetta qualche parametro nell'indirizzo, come `?mem=512` per dare più memoria o `?data=0` per ripartire ogni volta da un sistema pulito.

Da terminale, con Node installato:

```sh
npx unkernel                    # Alpine, con la rete dell'host
npx unkernel --distro debian    # Debian 13, circa 57 MB scaricati una volta
npx unkernel --mount .:/work    # la cartella corrente dentro la macchina
```

Per uscire si preme Ctrl-].

## Domande frequenti

### unkernel è una macchina virtuale come VirtualBox o QEMU?

No. Una macchina virtuale emula tutto il computer, kernel compreso. unkernel compila il kernel Linux direttamente in WebAssembly ed emula solo la CPU dei programmi (aarch64). Per questo chiamate di sistema e fork costano quasi come su un computer vero.

### Posso usare unkernel in produzione?

Oggi no, almeno non per servizi critici. Il progetto è nato a metà novembre 2026, è alla versione 0.2 e cambia ogni giorno. Va bene per prove, demo e prototipi.

### I miei dati finiscono su un server?

No. Il kernel gira nel tuo browser e il disco persistente è salvato nel browser. Esce dalla pagina solo il traffico di rete che generi tu, per esempio un `apk add`, che passa da un proxy Wisp.

### Che browser servono?

Un browser con JSPI: Chrome ed Edge dalla 137, Firefox dalla 153, Safari dalla 27 su macOS e qualunque browser su iOS e iPadOS 27. Se manca, la pagina lo dice.

### Si può usare con n8n?

Non c'è un nodo n8n per unkernel. Il modo più semplice è un piccolo servizio Node che usa l'SDK ed espone un endpoint HTTP: l'AI Agent di n8n lo chiama come strumento per eseguire in una macchina isolata il codice che scrive, invece di usare il nodo Execute Command sul server.

### Che licenza ha?

Il progetto è GPL-2.0-or-later, il kernel GPL-2.0. L'SDK JavaScript e la pagina web sono MIT, quindi si possono incorporare in un prodotto. Il pacchetto npm, che contiene anche il kernel, è dichiarato `MIT AND GPL-2.0-only`.

---

In bwlab seguiamo progetti come questo perché ogni tanto spostano il confine di cosa si può fare in un browser, e prima o poi entrano nei progetti dei clienti. Ci occupiamo di [sviluppo web](/sviluppo-web) e di [automazione e agenti AI](/ai-and-automation), anche con n8n: se stai pensando a demo eseguibili, ambienti di prova per il tuo team o un recinto sicuro dove far lavorare un agente, [scrivici](/contattaci) e valutiamo insieme se unkernel è già maturo per quello che ti serve o se conviene aspettare qualche versione.