Construir un kernel CAD en el navegador con Rust y WebGPU
Lecciones de KetchUp: cómo Rust y WebGPU hacen viable por fin un kernel CAD real en el navegador, y los errores que hundieron intentos anteriores.

Algo notablemente bueno ocurrió esta semana: un kernel CAD en el navegador dejó de ser un chiste. KetchUp, ahora renombrado BenchUp, presumiblemente para mantener aburridos a los abogados de marcas de Trimble, es un modelador de estilo SketchUp de código abierto escrito en Rust, renderizado con WebGPU, que funciona en una pestaña normal del navegador con una velocidad y un pulido que hacen que los usuarios de SketchUp, que llevan años sufriendo, se pongan audiblemente celosos. Sin cuenta. Sin nube. Un archivo .ketchup se descarga a tu disco, y todo el proyecto tiene licencia MIT.
Llevo dos décadas viendo intentos de «CAD en la web», y casi todos murieron de la misma forma: runtime equivocado, API de renderizado equivocada, idea equivocada de cuál es la parte difícil. Este proyecto acierta con suficientes de esas decisiones como para tratarlo como caso de estudio. Así que aquí va la autopsia al revés: los errores que hundieron a los modeladores web anteriores y las soluciones concretas que hacen que este se sienta como una app nativa.
Lección 1: el navegador nunca fue el cuello de botella; lo fue el runtime
Todos los proyectos de CAD web fallidos que me vienen a la mente hicieron el mismo primer movimiento: escribieron el motor geométrico en JavaScript, chocaron con un muro y concluyeron que el navegador no podía hacerlo. La conclusión era errónea. El navegador estaba bien. El problema era el runtime.
Piensa en lo que exige el modelado interactivo. Estás arrastrando una cara con Push/Pull, y cada movimiento del ratón dispara el recálculo de las caras afectadas, la inferencia de aristas, las pruebas de ajuste contra cada vértice cercano y una nueva subida de los buffers de vértices, sesenta veces por segundo. En JavaScript, el recolector de basura controla tu presupuesto de frame. No le importa que estés en mitad de un arrastre. Unos pocos milisegundos de recolección en el momento equivocado se perciben como lag, y el lag en una herramienta de modelado no es un inconveniente: rompe el circuito mental entre la mano y la forma. Por eso la versión web de SketchUp siempre se sintió, en palabras de sus propios usuarios, «más lenta y menos capaz» que la de escritorio.
Rust compilado a WebAssembly elimina toda esa clase de fallos. Obtienes memoria lineal que controlas, una disposición determinista para tus buffers de geometría y ningún recolector acechando entre frames. Y es crucial: no es que Wasm sea mágicamente más rápido en todo. Ya hemos cubierto que WebAssembly suele perder frente a JavaScript bien optimizado en trabajo intensivo en cadenas y cercano al DOM. Pero un kernel geométrico es la carga opuesta: bucles ajustados sobre grandes arrays planos de f32. Ahí es donde la memoria predecible gana y donde el modelo de objetos de JS más te pelea.
Así que la solución no es «hacer el navegador más rápido». Es «dejar de ejecutar un motor geométrico en un runtime pensado para documentos». El navegador es solo el mecanismo de entrega. Lo que corre dentro puede ser código de sistemas.
Lección 2: WebGPU frente a WebGL para renderizar CAD: sabe qué estás comprando
El segundo error es más sutil: asumir que WebGL basta porque «un modelador son solo triángulos». Renderizar triángulos sombreados es, efectivamente, lo fácil. Todo lo que rodea a los triángulos es donde WebGL te hace daño.
Un poco de historia, porque explica la API. WebGL es descendiente directo de OpenGL, que a su vez desciende de IRIS GL de SGI: una máquina de estados diseñada a finales de los ochenta para hardware que ya no existe. Se programa mutando estado global del contexto y esperando haber ajustado las perillas correctas antes de cada llamada de dibujo. Fue una buena abstracción para 1992. Para un viewport de CAD, necesitas constantemente cosas que le resultan torpes: selección en GPU (¿qué cara está bajo el cursor?), teselar caras con agujeros, calcular grosores de línea en espacio de pantalla para las aristas y gestionar buffers que cambian en cada frame. Todo eso se puede hacer en WebGL2, pero estarás atornillando trabajo con forma de cómputo a una API sin shaders de cómputo y con sincronización implícita por todas partes.
WebGPU arregla el modelo, no solo la velocidad. Pipelines explícitos en lugar de estado global oculto. Storage buffers y compute shaders, de modo que la teselación y la selección pueden vivir en la GPU, donde ya están los datos. Un modelo de errores que te dice qué hiciste mal en lugar de caerse en silencio. Y, esta es la parte que importa estratégicamente, el crate de Rust wgpu implementa esa misma API sobre Vulkan, Metal y Direct3D. Escribe tu renderizador una vez contra wgpu y compila a WebGPU en el navegador y a gráficos nativos en escritorio. Esa única decisión es la razón por la que BenchUp puede publicar builds para Windows, macOS, Linux y navegador desde un solo árbol de código.
La advertencia honesta: el soporte de WebGPU no es universal, y una herramienta seria necesita una ruta de respaldo con WebGL2; BenchUp requiere una u otra. Pero construir primero para WebGPU y degradar con elegancia es el orden correcto. El orden inverso es como acabas atrapado arquitectónicamente en 1992.
Lección 3: el kernel geométrico no es la parte difícil; lo es la inferencia
Aquí está el error que más me interesa, porque es un fallo de priorización, no de ingeniería. Cuando los desarrolladores se proponen clonar un modelador, casi siempre empiezan por el kernel geométrico: representaciones de frontera, operadores de Euler, robustez de booleanas. Es la parte intelectualmente más seria, así que debe ir primero. ¿Verdad?
Mal, y la historia muestra por qué. Los kernels de modelado sólido son un problema resuelto y convertido en commodity desde hace décadas: BRL-CAD hacía geometría sólida constructiva para el ejército de EE. UU. a finales de los setenta, Parasolid y ACIS industrializaron la representación de frontera en los ochenta, y OpenCASCADE es de código abierto desde 1999. Si un kernel potente fuera el producto, alguno de los muchos modeladores basados en OpenCASCADE se habría comido el almuerzo de SketchUp hace años. Ninguno lo hizo. Porque el genio de SketchUp, cuando @Last Software lo lanzó desde Boulder en 2000, no era su potencia geométrica. Era el motor de inferencia: la forma en que el cursor se ajusta a los puntos medios, se bloquea a los ejes rojo, verde y azul, y adivina el plano en el que estás dibujando. Los usuarios nunca escriben coordenadas. El software encuentra la mano donde está.
SketchUp es, en el fondo, un modelador de superficies maravillosamente simple: caras y aristas, sin necesidad de sólidos. Push/Pull es simplemente extruir una cara y coser los lados. La complejidad vive en la capa de interacción, que es donde KetchUp claramente invirtió su esfuerzo. La lógica de ajuste se parece a esto:
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)
}
Nada en esa función es matemáticamente profundo. La profundidad está en el orden de prioridades, en la tolerancia que escala con el zoom y en las treinta micro-conductas que hacen que se sienta telepático en vez de brusco. Eso son mil horas de ajuste, no mil páginas de teoría de kernels. Si estás construyendo un modelador, construye primero la capa de inferencia y mantén la geometría vergonzosamente tonta hasta que los usuarios exijan más.
El motor de inferencia es el producto. El kernel geométrico es fontanería. Clona la fontanería al final.

Lección 4: no construyas una UI de CAD con nodos del DOM
El cuarto error es el de forma tipo React. La arquitectura por defecto para una «app web con un canvas» es una aplicación DOM envuelta alrededor de un elemento <canvas>: barras de herramientas como divs, paneles como componentes, diálogos como portales. Para una app CRUD está bien. Para una herramienta de modelado, acabas de pegar un motor de maquetación que invalida estilos y hace reflow de forma impredecible en el costado de un renderizador que necesita cada microsegundo de su frame. Luego te toca depurar por qué el estado hover de tu barra de herramientas provoca un frame perdido mientras orbitas.
KetchUp toma el camino contrario: toda la interfaz se dibuja en la GPU, y el DOM se reduce a un único canvas. Es el mismo movimiento arquitectónico que hicieron los emuladores de terminal acelerados por GPU: Alacritty y compañía dejaron de pedirle al DOM que renderizara texto celda por celda y empezaron a tratar la ventana como una textura. Vimos lo bien que funcionó en el enfoque de atlas de glifos de la terminal moderna. El ecosistema de Rust lo hace casi gratis: una GUI de modo inmediato como egui compila a Wasm, renderiza a través de wgpu y te da botones, paneles y texto sin un solo nodo del DOM. Un comentarista de Hacker News, sorprendido de lo nativo que se sentía, destacó específicamente el renderizado de texto. No es casualidad: el texto es donde las UI sin DOM suelen fallar, y acertar con él es señal de que la pila de renderizado es realmente sólida.
El compromiso es real, así que hay que nombrarlo: la UI de modo inmediato vuelve a maquetar en cada frame, las herramientas de accesibilidad asumen un DOM, y renuncias a todo lo que trae el navegador de serie. Para una superficie de herramientas con unos cientos de widgets redibujados a 60 fps, el coste de recálculo es irrelevante. El coste de accesibilidad es el que debería mantenerte honesto, pero es un coste que mitigar, no una razón para volver a las tormentas de reflow.
Lección 5: los archivos locales primero vencen al bloqueo en la nube
Ahora el error que no es técnico en absoluto. Cuando Trimble adquirió SketchUp a Google en 2012, el producto recorrió lentamente el camino conocido: la versión gratuita de escritorio (SketchUp Make) se descontinuó, el nivel gratuito pasó a ser una app web tras una cuenta, y las licencias perpetuas se eliminaron a favor de suscripciones que cuestan cientos al año. El resentimiento en la comunidad no es realmente por el dinero: los aficionados repiten que pagarían gustosos un precio único justo. Es por las condiciones. La gente tiene modelos de casas en los que lleva años trabajando, guardados en un formato y un régimen de licencias que pueden reprecirse por encima de ellos. Un comentarista todavía usa la versión gratuita de 2017 bajo WINE antes que aceptar el nuevo trato. Eso no es nostalgia. Es una negociación de rehenes.
La solución de KetchUp es casi desafiantemente anticuada: el autoguardado va al almacenamiento del navegador en tu dispositivo, Archivo → Guardar descarga un archivo de proyecto .ketchup portable, las geometrías .skp de SketchUp se importan localmente, y la exportación OBJ está ahí cuando quieres salir. No hay servidor. No hay cuenta. La documentación incluso te advierte, en lenguaje llano, que borrar los datos del navegador elimina tus autoguardados, que es el intercambio honesto del software local primero, dicho desde el principio.
Esta es la parte que quiero subrayar, porque es la lección más antigua de la pieza: el formato de archivo es el bloqueo, y la interoperabilidad es la palanca. Todo retador exitoso de una herramienta consolidada empezó leyendo los archivos del incumbente. WordPerfect perdió frente a los filtros de importación de Word, no frente a su lista de funciones. La importación de SketchUp importa más para la adopción de KetchUp que cualquier función de modelado individual. Que la exportación OBJ sea solo de geometría (sin materiales) es un defecto aceptable; indica que la dirección es hacia fuera, no hacia dentro.
Lección 6: escribe una vez en Rust, ejecuta de forma nativa y en la web
El último error es tratar «la versión web» como un producto aparte. Históricamente así ha sido: una base de código nativa en C++ y luego un esfuerzo web paralelo, años por detrás y eternamente inferior. Los usuarios podían sentir cuál era el producto real y cuál la demo.
La pila sobre la que se apoya KetchUp hace que esa distinción desaparezca. Rust trata Wasm como un destino de primera clase. wgpu habla WebGPU en el navegador y Vulkan, Metal y D3D en escritorio. egui funciona en ambos sitios sin cambios. Las builds del navegador y las nativas no son primos: son el mismo programa, compilado dos veces. No puedo resistirme a señalar que esta es la promesa que Java hizo en 1995 finalmente cumplida, por un formato de bytecode sin recolector de basura y sin ideología de lenguaje adjunta. WebAssembly triunfó como objetivo de compilación precisamente porque nunca intentó ser una plataforma en la que escribir. El navegador se ha convertido discretamente en un destino creíble para código de calidad nativa: lo hemos visto con ports de juegos de consola recompilados estáticamente que corren en pestañas, y el CAD es simplemente el siguiente género en caer.

Hay un matiz más que vale la pena considerar. Por lo que se ve, este proyecto se construyó en gran parte con asistencia de IA para programar: la comunidad lo notó enseguida, y la respuesta fue sobre todo encogerse de hombros y elogiar. Eso encaja con un patrón que varios comentaristas nombraron abiertamente: estamos entrando en una era en la que construir tu propia herramienta es una alternativa realista a aprender la de otro. Una sola persona motivada, armada con Rust, wgpu y un compañero de IA, ahora puede reproducir el bucle central de un producto que una empresa pública alquila por cientos al año. Que esa era te deleite o te alarme probablemente depende de en qué lado de la factura estés.
KetchUp quizá sea o no el proyecto que por fin dé a los modeladores aficionados un hogar permanente: es joven, el núcleo geométrico es simple, y los fieles de SketchUp con modelos enormes encontrarán su límite rápido. Pero como prueba de existencia, ya ha cumplido su función. El navegador nunca fue demasiado débil para el CAD. Simplemente lo estábamos construyendo mal: runtime equivocado, API equivocada, prioridades equivocadas, modelo de negocio equivocado. Arregla esas cuatro cosas, y una suscripción de 300 dólares al año empieza a parecer un impuesto a la inercia.


