Costruire un kernel CAD nel browser con Rust e WebGPU
Lezioni da KetchUp: come Rust e WebGPU rendono finalmente possibile un kernel CAD nel browser e gli errori che hanno affossato i tentativi precedenti.

Qualcosa di silenziosamente notevole è successo questa settimana: un kernel CAD nel browser ha smesso di essere una battuta. KetchUp — ribattezzato BenchUp, presumibilmente per tenere tranquilli gli avvocati dei marchi di Trimble — è un modellatore open source in stile SketchUp scritto in Rust, renderizzato con WebGPU, che gira in una normale scheda del browser con una velocità e una cura dei dettagli che fanno invidia, quasi udibilmente, agli utenti di SketchUp di lunga data. Nessun account. Nessun cloud. Un file .ketchup si scarica sul disco, e l'intero progetto è rilasciato con licenza MIT.
Vedo gente provare il «CAD sul web» da vent'anni, e quasi ogni tentativo è morto allo stesso modo: runtime sbagliato, API di rendering sbagliata, idea sbagliata su quale sia la parte difficile. Questo progetto azzecca abbastanza di quelle decisioni da meritare di essere studiato come caso di scuola. Quindi ecco l'autopsia al contrario: gli errori che hanno affondato i modellatori browser precedenti e le soluzioni specifiche che fanno sembrare questo un'app nativa.
Lezione 1: il browser non è mai stato il collo di bottiglia — lo era il runtime
Ogni progetto di CAD web fallito che mi viene in mente ha fatto la stessa mossa iniziale: hanno scritto il motore geometrico in JavaScript, hanno sbattuto contro un muro e hanno concluso che il browser non ce la facesse. La conclusione era sbagliata. Il browser andava benissimo. Il problema era il runtime.
Pensa a cosa richiede davvero la modellazione interattiva. Stai trascinando una faccia con Push/Pull, e ogni movimento del mouse innesca il ricalcolo delle facce interessate, l'inferenza degli spigoli, il test di aggancio (snap) rispetto a ogni vertice vicino e il ricaricamento dei buffer dei vertici — sessanta volte al secondo. In JavaScript, il garbage collector controlla il budget di frame. Non gli importa che tu stia trascinando qualcosa. Qualche millisecondo di raccolta nel momento sbagliato appare all'utente come lag, e il lag in uno strumento di modellazione non è un fastidio: rompe il circuito mentale tra mano e forma. Ecco perché la versione web di SketchUp è sempre sembrata, parole dei suoi stessi utenti, «più lenta e meno capace» di quella desktop.
Rust compilato in WebAssembly elimina un'intera classe di problemi. Ottieni una memoria lineare che controlli, un layout deterministico per i buffer geometrici e nessun collector in agguato tra un frame e l'altro. Il punto non è che Wasm sia magicamente più veloce in tutto — abbiamo già spiegato che WebAssembly spesso perde contro un JavaScript ben ottimizzato nei lavori pesanti di stringhe e vicini al DOM. Ma un kernel geometrico è il carico di lavoro opposto: cicli stretti su grandi array piatti di f32. È esattamente lì che una memoria prevedibile vince, e dove il modello a oggetti di JS ti ostacola di più.
La soluzione, quindi, non è «rendere il browser più veloce». È «smettere di far girare un motore geometrico su un runtime pensato per i documenti». Il browser è solo il meccanismo di distribuzione. Ciò che gira al suo interno può essere codice di sistema.
Lezione 2: WebGPU vs WebGL per il rendering CAD — sai cosa stai comprando
Il secondo errore è più sottile: presumere che WebGL basti perché «un modellatore sono solo triangoli». Renderizzare triangoli ombreggiati è davvero la parte facile. È tutto il contorno dei triangoli a far male con WebGL.
Un po' di storia, perché spiega l'API. WebGL discende direttamente da OpenGL, che discende dall'IRIS GL di SGI — una macchina a stati progettata alla fine degli anni Ottanta per hardware che non esiste più. Lo si programma mutando lo stato globale del contesto e sperando di aver impostato le manopole giuste prima di ogni draw call. Era un'astrazione valida per il 1992. Per un viewport CAD servono continuamente cose che lui rende scomode: il picking lato GPU (quale faccia è sotto il cursore?), la tassellazione di facce con fori, il calcolo della larghezza delle linee degli spigoli in spazio schermo, la gestione di buffer che cambiano a ogni frame. Tutto questo si può fare in WebGL2, ma stai agganciando lavoro di tipo compute a un'API senza compute shader e con sincronizzazione implicita ovunque.
WebGPU cambia il modello, non solo la velocità. Pipeline esplicite invece di stato globale nascosto. Storage buffer e compute shader, così tassellazione e picking possono vivere sulla GPU, dove i dati già si trovano. Un modello di errori che ti dice cosa hai sbagliato invece di cadere in silenzio. E — ed è la parte che conta strategicamente — il crate Rust wgpu implementa la stessa API sopra Vulkan, Metal e Direct3D. Scrivi il renderer una volta con wgpu e si compila in WebGPU nel browser e in grafica nativa sul desktop. È questa decisione singola a permettere a BenchUp di distribuire build per Windows, macOS, Linux e browser da un unico albero di sorgenti.
La precisazione onesta: il supporto a WebGPU non è universale, e uno strumento serio ha bisogno di un ripiego su WebGL2 — BenchUp richiede l'uno o l'altro. Ma costruire prima per WebGPU e degradare con eleganza è l'ordine giusto. Quello inverso è il modo in cui finisci architetturalmente intrappolato nel 1992.
Lezione 3: il kernel geometrico non è la parte difficile — lo è l'inferenza
Qui c'è l'errore che trovo più interessante, perché è un fallimento di priorità, non di ingegneria. Quando gli sviluppatori decidono di clonare un modellatore, quasi sempre partono dal kernel geometrico: rappresentazioni di frontiera, operatori di Eulero, robustezza delle booleane. È la parte più seria dal punto di vista intellettuale, quindi deve venire per prima. Giusto?
Sbagliato, e la storia spiega perché. I kernel di modellazione solida sono un problema risolto e ormai commodity, che risale a decenni fa: BRL-CAD faceva geometria solida costruttiva per l'esercito americano alla fine degli anni Settanta, Parasolid e ACIS hanno industrializzato la rappresentazione di frontiera negli anni Ottanta, e OpenCASCADE è open source dal 1999. Se un kernel potente fosse il prodotto, uno dei tanti modellatori basati su OpenCASCADE avrebbe già mangiato il pranzo a SketchUp anni fa. Nessuno ci è riuscito. Perché il genio di SketchUp, quando @Last Software lo rilasciò da Boulder nel 2000, non stava nella potenza geometrica. Stava nel motore di inferenza: il modo in cui il cursore si aggancia ai punti medi, si blocca sugli assi rosso-verde-blu e indovina il piano su cui stai disegnando. Gli utenti non digitano mai coordinate. Il software incontra la mano dove si trova.
SketchUp, sotto sotto, è un modellatore di superfici meravigliosamente semplice — facce e spigoli, senza bisogno di solidi. Push/Pull è semplicemente estrudere una faccia e cucire i lati. La complessità vive nello strato di interazione, ed è lì che KetchUp ha chiaramente concentrato lo sforzo. La logica di aggancio è più o meno questa:
enum Inference {
AtVertex(VertexId),
Midpoint(EdgeId),
OnEdge(EdgeId),
OnAxis(Axis), // the famous red / green / blue lock
OnFace(FaceId),
None,
}
fn infer(ray: Ray, model: &Model, last_point: Vec3, tol: f32) -> (Vec3, Inference) {
// Priority order matters more than cleverness:
// hard snaps beat soft snaps, every time.
if let Some(v) = model.nearest_vertex(ray, tol) {
return (v.pos, Inference::AtVertex(v.id));
}
if let Some((e, t)) = model.nearest_midpoint(ray, tol) {
return (e.point_at(t), Inference::Midpoint(e.id));
}
if let Some(p) = snap_to_axis(ray, last_point, tol) {
return (p, Inference::OnAxis(p.axis));
}
// Fall through to whatever face or plane the ray hits.
project_onto_surface(ray, model)
}
Niente in quella funzione è matematicamente profondo. La profondità sta nell'ordine di priorità, nella tolleranza che scala con lo zoom e nelle trenta micro-componenti del comportamento che la fanno sembrare telepatica invece che a scatti. Sono mille ore di messa a punto, non mille pagine di teoria dei kernel. Se stai costruendo un modellatore, costruisci prima lo strato di inferenza e tieni la geometria vergognosamente semplice finché gli utenti non la richiedono.
Il motore di inferenza è il prodotto. Il kernel geometrico è la tubatura. Clona la tubatura per ultima.

Lezione 4: non costruire una UI CAD con nodi DOM
Il quarto errore è quello a forma di React. L'architettura predefinita per una «web app con un canvas» è un'applicazione DOM avvolta attorno a un elemento <canvas>: barre degli strumenti come div, pannelli come componenti, finestre di dialogo come portali. Per un'app CRUD va bene. Per uno strumento di modellazione, hai appena incollato un motore di layout che invalida gli stili e fa reflow imprevedibili sul fianco di un renderer che ha bisogno di ogni microsecondo del suo frame. Poi ti ritrovi a fare debug del perché lo stato hover della tua barra strumenti causa un frame perso mentre ruoti la vista.
KetchUp va nella direzione opposta: l'intera UI è disegnata sulla GPU e il DOM si riduce a un singolo canvas. È la stessa mossa architetturale fatta dai terminali accelerati via GPU — Alacritty e compagni hanno smesso di chiedere al DOM di renderizzare il testo cella per cella e hanno iniziato a trattare la finestra come una texture. Abbiamo visto quanto ha funzionato bene in l'approccio a glyph atlas dei terminali moderni. L'ecosistema Rust lo rende quasi gratuito: una GUI in modalità immediata come egui si compila in Wasm, renderizza tramite wgpu e ti dà pulsanti, pannelli e testo senza un singolo nodo DOM. Un commentatore di Hacker News, sorpreso da quanto sembrasse nativo, ha citato proprio il rendering del testo. Non è una coincidenza: il testo è dove le UI senza DOM di solito cadono, e farlo bene è segno che lo stack di rendering è davvero solido.
Il compromesso è reale, quindi va dichiarato: la UI in modalità immediata ricalcola il layout a ogni frame, gli strumenti di accessibilità presuppongono un DOM e rinunci a tutto ciò che il browser offre di serie. Per una superficie di strumenti con qualche centinaio di widget ridisegnati a 60 fps, il costo del ricalcolo è rumore. Il costo sull'accessibilità è quello che dovrebbe tenerti onesto — ma è un costo da mitigare, non un motivo per riportare le tempeste di reflow.
Lezione 5: i file locali-first battono il lock-in del cloud
Ora l'errore che non è affatto tecnico. Quando Trimble acquisì SketchUp da Google nel 2012, il prodotto percorse lentamente la strada ormai nota: la versione desktop gratuita (SketchUp Make) fu dismessa, il livello gratuito diventò un'app web dietro un account e le licenze perpetue furono eliminate a favore di abbonamenti da centinaia di dollari l'anno. Il risentimento della community non riguarda davvero i soldi — gli hobbisti ripetono che pagherebbero volentieri un prezzo unico equo. Riguarda i termini. Le persone hanno modelli di case su cui hanno lavorato per anni, custoditi in un formato e in un regime di licenza che può essere riprezzato sotto i loro piedi. Un commentatore usa ancora la build gratuita del 2017 sotto WINE piuttosto che accettare il nuovo accordo. Non è nostalgia. È una trattativa con ostaggi.
La soluzione di KetchUp è quasi volutamente vecchio stile: il salvataggio automatico va nello storage del browser sul tuo dispositivo, File → Salva scarica un file di progetto .ketchup portabile, l'import della geometria .skp di SketchUp avviene in locale e l'export OBJ c'è quando vuoi andartene. Non c'è un server. Non c'è un account. La documentazione ti avverte persino, in parole semplici, che cancellare i dati del browser elimina i salvataggi automatici — che è il compromesso onesto del software local-first, dichiarato fin dall'inizio.
Questa è la parte che voglio sottolineare, perché è la lezione più antica del pezzo: il formato del file è il lock-in, e l'interoperabilità è il piede di porco. Ogni sfidante di successo di uno strumento consolidato ha cominciato leggendo i file dell'incumbent — WordPerfect ha perso contro i filtri di importazione di Word, non contro la sua lista di funzionalità. L'import di SketchUp conta per l'adozione di KetchUp più di qualsiasi singola funzione di modellazione. Il fatto che l'export OBJ sia solo geometria (senza materiali) è un difetto accettabile; segnala che la direzione è verso l'esterno, non verso l'interno.
Lezione 6: scrivi una volta in Rust, esegui in nativo e sul web
L'ultimo errore è trattare la «versione web» come un prodotto separato. Storicamente è andata così: una base di codice nativa in C++, e poi uno sforzo web parallelo, anni indietro, per sempre inferiore. Gli utenti sentivano quale fosse il prodotto vero e quale la demo.
Lo stack su cui poggia KetchUp fa svanire la distinzione. Rust tratta Wasm come target di prima classe. wgpu parla WebGPU nel browser e Vulkan/Metal/D3D sul desktop. egui gira in entrambi i posti senza modifiche. La build browser e quelle native non sono cugine: sono lo stesso programma, compilato due volte. Non resisto a far notare che questa è la promessa che Java fece nel 1995, finalmente mantenuta, da un formato bytecode senza garbage collector e senza ideologia linguistica annessa. WebAssembly ha avuto successo come target di compilazione proprio perché non ha mai cercato di essere una piattaforma in cui scrivere. Il browser è diventato silenziosamente una destinazione credibile per codice di qualità nativa — lo abbiamo visto con i giochi per console ricompilati staticamente che girano nelle schede, e il CAD è solo il prossimo genere a cadere.

C'è un'ultima sfumatura su cui vale la pena riflettere. A giudicare dalle apparenze, il progetto è stato costruito in gran parte con l'assistenza di un coding AI — la community l'ha notato subito, e la risposta è stata per lo più alzate di spalle e complimenti. Questo si inserisce in uno schema che diversi commentatori hanno citato apertamente: stiamo entrando in un'era in cui costruirsi il proprio strumento è un'alternativa realistica all'imparare quello di qualcun altro. Una singola persona motivata, armata di Rust, wgpu e un partner AI, può oggi riprodurre il ciclo centrale di un prodotto che una società quotata affitta per centinaia di dollari l'anno. Se quell'era ti entusiasmi o ti allarmi dipende probabilmente da quale lato della fattura ti trovi.
KetchUp potrebbe o non potrebbe essere il progetto che finalmente dà agli hobbisti della modellazione una casa stabile — è giovane, il nucleo geometrico è semplice e i fan più ostinati di SketchUp con modelli enormi troveranno presto il suo limite. Ma come prova dell'esistenza, ha già fatto il suo lavoro. Il browser non è mai stato troppo debole per il CAD. Stavamo solo costruendo nel modo sbagliato: runtime sbagliato, API sbagliata, priorità sbagliate, modello di business sbagliato. Sistemate queste quattro cose, un abbonamento da 300 dollari l'anno inizia a sembrare una tassa sull'inerzia.


