Un noyau CAO dans le navigateur avec Rust et WebGPU
Leçons de KetchUp : Rust et WebGPU rendent enfin viable un vrai noyau CAO dans le navigateur, et évitent les erreurs qui ont coulé les tentatives passées.

Quelque chose de remarquable s'est discrètement produit cette semaine : un noyau CAO dans le navigateur a cessé d'être une plaisanterie. KetchUp, rebaptisé BenchUp sans doute pour éviter d'ennuyer les avocats de la marque Trimble, est un modeleur open source de type SketchUp écrit en Rust, rendu avec WebGPU, qui tourne dans un simple onglet de navigateur avec une vitesse et un soin du détail qui font grincer des dents les utilisateurs de SketchUp habitués à souffrir. Pas de compte. Pas de cloud. Un fichier .ketchup se télécharge sur votre disque, et l'ensemble est sous licence MIT.
Je vois des gens tenter la « CAO sur le web » depuis vingt ans, et presque chaque tentative est morte de la même façon : mauvais runtime, mauvaise API de rendu, mauvaise idée de la partie difficile. Ce projet prend suffisamment de bonnes décisions pour mériter d'être étudié. Voici donc une autopsie à l'envers : les erreurs qui ont coulé les anciens modeleurs web, et les correctifs précis qui donnent à celui-ci l'impression d'une application native.
Leçon 1 : le navigateur n'a jamais été le goulot d'étranglement, c'est le runtime
Chaque projet de CAO web raté que je peux citer a fait le même premier choix : écrire le moteur géométrique en JavaScript, se heurter à un mur, puis conclure que le navigateur ne pouvait pas le faire. La conclusion était fausse. Le navigateur allait très bien. C'est le runtime le problème.
Pensez à ce que la modélisation interactive exige vraiment. Vous faites glisser une face avec Push/Pull, et chaque mouvement de souris déclenche le recalcul des faces concernées, l'inférence des arêtes, le test d'accrochage contre chaque sommet proche, et le renvoi des tampons de sommets, soixante fois par seconde. En JavaScript, le ramasse-miettes gère votre budget d'image. Il se moque que vous soyez en plein glisser-déposer. Quelques millisecondes de collecte au mauvais moment se traduisent pour l'utilisateur par du lag, et dans un outil de modélisation le lag n'est pas un simple désagrément : il casse la boucle mentale entre la main et la forme. C'est pour cela que la version web de SketchUp a toujours paru, selon les mots de ses propres utilisateurs, « plus lente et moins capable » que la version de bureau.
Rust compilé en WebAssembly élimine toute cette famille de problèmes. Vous disposez d'une mémoire linéaire que vous contrôlez, d'une disposition déterministe pour vos tampons géométriques, et d'aucun collecteur qui rôde entre deux images. Attention, il ne s'agit pas de dire que Wasm est magiquement plus rapide en tout : nous avons déjà expliqué pourquoi WebAssembly perd souvent face à du JavaScript bien optimisé sur les traitements de chaînes et le travail proche du DOM. Mais un noyau géométrique est la charge inverse : des boucles serrées sur de grands tableaux plats de f32. C'est précisément là que une mémoire prévisible gagne, et là où le modèle objet de JS vous résiste le plus.
Le correctif n'est donc pas « rendre le navigateur plus rapide ». Il consiste à « arrêter de faire tourner un moteur géométrique sur un runtime conçu pour des documents ». Le navigateur n'est que le mécanisme de livraison. Ce qui s'exécute à l'intérieur peut être du code système.
Leçon 2 : WebGPU ou WebGL pour le rendu CAO, sachez ce que vous achetez
La deuxième erreur est plus subtile : supposer que WebGL suffit parce qu'« un modeleur ne fait que des triangles ». Afficher des triangles ombrés est effectivement la partie facile. Tout ce qui entoure les triangles est là où WebGL vous fait souffrir.
Un peu d'histoire, car elle explique l'API. WebGL descend directement d'OpenGL, lui-même issu de l'IRIS GL de SGI, une machine à états conçue à la fin des années 80 pour un matériel qui n'existe plus. On le programme en modifiant un état global du contexte et en espérant avoir réglé les bons paramètres avant chaque appel de dessin. C'était une abstraction correcte pour 1992. Pour une fenêtre de visualisation CAO, vous avez constamment besoin de choses qu'elle rend pénibles : le picking côté GPU (quelle face se trouve sous le curseur ?), la tessellation de faces avec des trous, le calcul de l'épaisseur des arêtes en espace écran, la gestion de tampons qui changent à chaque image. Tout cela est faisable en WebGL2, mais vous greffez du travail de type calcul sur une API sans shaders de calcul et avec une synchronisation implicite partout.
WebGPU corrige le modèle, pas seulement la vitesse. Des pipelines explicites au lieu d'un état global caché. Des storage buffers et des compute shaders, afin que la tessellation et le picking puissent vivre sur le GPU, là où se trouvent déjà les données. Un modèle d'erreurs qui vous dit ce que vous avez mal fait au lieu de planter silencieusement. Et, c'est le point stratégique important, la crate Rust wgpu implémente cette même API au-dessus de Vulkan, Metal et Direct3D. Vous écrivez votre moteur de rendu une seule fois avec wgpu, il se compile en WebGPU dans le navigateur et en graphismes natifs sur le bureau. C'est cette décision unique qui permet à BenchUp de livrer des builds Windows, macOS, Linux et navigateur à partir d'un seul arbre de sources.
La mise en garde honnête : le support de WebGPU n'est pas universel, et un outil sérieux a besoin d'un repli WebGL2. BenchUp exige l'un ou l'autre. Mais construire d'abord pour WebGPU puis dégrader proprement reste le bon ordre. L'ordre inverse est la façon de se retrouver architecturalement coincé en 1992.
Leçon 3 : le noyau géométrique n'est pas la partie difficile, c'est l'inférence
Voici l'erreur que je trouve la plus intéressante, parce que c'est un échec de priorisation, pas d'ingénierie. Quand des développeurs veulent cloner un modeleur, ils commencent presque toujours par le noyau géométrique : représentations par frontière, opérateurs d'Euler, robustesse des booléens. C'est la partie la plus sérieuse intellectuellement, donc elle doit venir en premier. Non ?
Faux, et l'histoire montre pourquoi. Les noyaux de modélisation de solides sont un problème résolu et banalisé depuis des décennies : BRL-CAD faisait de la géométrie de construction de solides pour l'armée américaine à la fin des années 70, Parasolid et ACIS ont industrialisé la représentation par frontière dans les années 80, et OpenCASCADE est open source depuis 1999. Si un noyau puissant était le produit, un des nombreux modeleurs basés sur OpenCASCADE aurait mangé le déjeuner de SketchUp depuis des années. Aucun ne l'a fait. Parce que le génie de SketchUp, lorsque @Last Software l'a sorti de Boulder en 2000, ne résidait pas dans sa puissance géométrique. C'était le moteur d'inférence : la façon dont le curseur s'accroche aux milieux, se verrouille sur les axes rouge-vert-bleu et devine le plan sur lequel vous dessinez. Les utilisateurs ne tapent jamais de coordonnées. Le logiciel rejoint la main là où elle se trouve.
SketchUp est, au fond, un modeleur de surfaces magnifiquement simple : des faces et des arêtes, pas besoin de solides. Push/Pull consiste simplement à extruder une face et à recoudre les côtés. La complexité vit dans la couche d'interaction, et c'est là que KetchUp a clairement concentré ses efforts. La logique d'accrochage ressemble à ceci :
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)
}
Rien dans cette fonction n'est mathématiquement profond. La profondeur réside dans l'ordre de priorité, la tolérance qui s'adapte au zoom, et les trente micro-comportements qui la rendent presque magique au lieu de saccadée. C'est mille heures de réglages, pas mille pages de théorie des noyaux. Si vous construisez un modeleur, commencez par la couche d'inférence et gardez la géométrie désespérément simple jusqu'à ce que les utilisateurs en réclament davantage.
Le moteur d'inférence est le produit. Le noyau géométrique n'est que de la tuyauterie. Clonez la tuyauterie en dernier.

Leçon 4 : ne construisez pas une interface CAO avec des nœuds DOM
La quatrième erreur est celle de l'architecture en React. L'architecture par défaut d'une « application web avec un canvas » est une application DOM enveloppée autour d'un élément <canvas> : barres d'outils en div, panneaux en composants, boîtes de dialogue en portails. Pour une application CRUD, c'est très bien. Pour un outil de modélisation, vous venez de coller un moteur de mise en page qui invalide les styles et reflow de façon imprévisible sur le flanc d'un moteur de rendu qui a besoin de chaque microseconde de son image. Ensuite vous passez vos journées à comprendre pourquoi l'état survol de votre barre d'outils fait perdre une image pendant la rotation.
KetchUp prend le chemin inverse : toute l'interface est dessinée sur le GPU, et le DOM se réduit à un seul canvas. C'est le même mouvement architectural qu'ont fait les émulateurs de terminal accélérés par GPU : Alacritty et consorts ont cessé de demander au DOM de rendre le texte cellule par cellule et ont traité la fenêtre comme une texture. Nous avons vu à quel point cette approche fonctionne dans l'approche par atlas de glyphes des terminaux modernes. L'écosystème Rust rend cela presque gratuit : une GUI en mode immédiat comme egui se compile en Wasm, s'affiche via wgpu, et fournit boutons, panneaux et texte sans un seul nœud DOM. Un commentateur de Hacker News, surpris par le côté natif de l'ensemble, a spécifiquement salué le rendu du texte. Ce n'est pas un hasard : le texte est justement là où les interfaces sans DOM trébuchent d'habitude, et le réussir est le signe que la pile de rendu est vraiment solide.
Le compromis est réel, il faut donc le nommer : l'interface en mode immédiat recalcule la mise en page à chaque image, les outils d'accessibilité supposent un DOM, et vous renoncez à tout ce que le navigateur fournit d'office. Pour une surface d'outils de quelques centaines de widgets redessinés à 60 images par seconde, le coût du recalcul est négligeable. Le coût en accessibilité est celui qui doit vous garder honnête, mais c'est un coût à atténuer, pas une raison de ramener les tempêtes de reflow.
Leçon 5 : les fichiers locaux d'abord battent l'enfermement dans le cloud
Passons à l'erreur qui n'est pas du tout technique. Quand Trimble a racheté SketchUp à Google en 2012, le produit a suivi lentement le chemin familier : la version gratuite de bureau (SketchUp Make) a été abandonnée, le niveau gratuit est devenu une application web derrière un compte, et les licences perpétuelles ont été supprimées au profit d'abonnements coûtant des centaines d'euros par an. Le ressentiment de la communauté ne porte pas vraiment sur l'argent : les amateurs répètent qu'ils paieraient volontiers un prix unique juste. Il porte sur les conditions. Les gens ont des maquettes de maisons sur lesquelles ils ont passé des années, enregistrées dans un format et un régime de licence qui peuvent être réévalués sous leurs pieds. Un commentateur fait encore tourner la version gratuite 2017 sous WINE plutôt que d'accepter le nouveau contrat. Ce n'est pas de la nostalgie. C'est une négociation d'otages.
Le correctif de KetchUp est d'une vieillesse presque délibérément assumée : la sauvegarde automatique va dans le stockage du navigateur sur votre appareil, Fichier → Enregistrer télécharge un fichier de projet .ketchup portable, l'import de géométries .skp de SketchUp se fait localement, et l'export OBJ est là quand vous voulez partir. Il n'y a pas de serveur. Il n'y a pas de compte. La documentation vous prévient même, en clair, que vider les données du navigateur supprime vos sauvegardes automatiques, ce qui est le compromis honnête du logiciel local d'abord, annoncé dès le départ.
C'est la partie que je veux souligner, car c'est la plus ancienne leçon de cet article : le format de fichier est le verrou, et l'interopérabilité est le pied-de-biche. Chaque challenger couronné de succès face à un outil installé a commencé par lire les fichiers de l'acteur en place. WordPerfect a perdu face aux filtres d'import de Word, pas face à sa liste de fonctionnalités. L'import SketchUp compte davantage pour l'adoption de KetchUp que n'importe quelle fonctionnalité de modélisation prise isolément. Le fait que l'export OBJ ne contienne que la géométrie (sans matériaux) est un défaut acceptable ; il signale que la direction est tournée vers l'extérieur, pas vers l'intérieur.
Leçon 6 : écrire une fois en Rust, exécuter en natif comme sur le web
La dernière erreur consiste à traiter « la version web » comme un produit à part. Historiquement, c'est ainsi que les choses se passaient : une base de code native en C++, puis un effort web parallèle, des années en retard et toujours moins bon. Les utilisateurs sentaient lequel était le vrai produit et lequel était la démo.
La pile sur laquelle repose KetchUp fait disparaître cette distinction. Rust traite Wasm comme une cible de première classe. wgpu parle WebGPU dans le navigateur et Vulkan/Metal/D3D sur le bureau. egui fonctionne sans changement aux deux endroits. Les builds navigateur et natifs ne sont pas des cousins : c'est le même programme, compilé deux fois. Je ne résiste pas à souligner que c'est la promesse que Java avait faite en 1995 enfin tenue, par un format de bytecode sans ramasse-miettes et sans idéologie de langage attachée. WebAssembly a réussi comme cible de compilation précisément parce qu'il n'a jamais cherché à être une plateforme dans laquelle on écrit. Le navigateur est discrètement devenu une destination crédible pour du code de qualité native : nous l'avons vu avec les jeux de console recompilés statiquement qui tournent dans des onglets, et la CAO n'est que le prochain genre à tomber.

Il reste un détail qui mérite réflexion. Selon toute apparence, ce projet a été construit en grande partie avec l'aide d'un assistant de code IA : la communauté l'a remarqué immédiatement, et la réaction a été surtout haussements d'épaules et éloges. Cela correspond à une tendance que plusieurs commentateurs ont nommée explicitement : nous entrons dans une ère où construire son propre outil est une alternative réaliste à l'apprentissage de l'outil d'un autre. Une seule personne motivée, armée de Rust, de wgpu et d'un binôme IA, peut aujourd'hui reproduire la boucle centrale d'un produit qu'une entreprise cotée loue à plusieurs centaines par an. Que cette ère vous enchante ou vous inquiète dépend probablement de quel côté de la facture vous vous trouvez.
KetchUp sera peut-être, ou peut-être pas, le projet qui offrira enfin aux modélisateurs amateurs un foyer durable : il est jeune, le cœur géométrique est simple, et les fans de SketchUp avec d'énormes modèles en atteindront vite le plafond. Mais comme preuve d'existence, il a déjà fait son travail. Le navigateur n'a jamais été trop faible pour la CAO. Nous le construisions simplement mal : mauvais runtime, mauvaise API, mauvaises priorités, mauvais modèle économique. Corrigez ces quatre points, et un abonnement à 300 dollars par an commence à ressembler à une taxe sur l'inertie.


