Construindo um Kernel CAD no Navegador com Rust e WebGPU
Lições do KetchUp: como Rust e WebGPU tornam viável um kernel CAD real no navegador, e os erros que mataram tentativas anteriores.

Algo discretamente notável aconteceu esta semana: um kernel CAD no navegador deixou de ser piada. O KetchUp, depois renomeado para BenchUp, presumivelmente para manter os advogados de marcas da Trimble entediados, é um modelador open source no estilo SketchUp, escrito em Rust e renderizado com WebGPU. Ele roda em uma aba comum do navegador com uma velocidade e um acabamento que deixam usuários de longa data do SketchUp audivelmente com inveja. Sem conta. Sem nuvem. Um arquivo .ketchup é baixado para o seu disco, e tudo é licenciado sob MIT.
Acompanho tentativas de “CAD na web” há duas décadas, e quase todas morreram do mesmo jeito: runtime errado, API de renderização errada, ideia errada sobre qual é a parte difícil. Este projeto acerta decisões suficientes para valer a pena ser tratado como estudo de caso. Então aqui vai a autópsia de trás para frente: os erros que afundaram os modeladores anteriores para navegador e as correções específicas que fazem este parecer um app nativo.
Lição 1: O navegador nunca foi o gargalo, o runtime era
Todo projeto de CAD web que me vem à cabeça fez o mesmo primeiro movimento: escreveram o motor geométrico em JavaScript, bateram numa parede e concluíram que o navegador não dava conta. A conclusão estava errada. O navegador estava bem. O problema era o runtime.
Pense no que a modelagem interativa realmente exige. Você arrasta uma face com Push/Pull, e a cada movimento do mouse acontece um recálculo das faces afetadas, inferência de arestas, teste de snap contra cada vértice próximo e um reenvio dos buffers de vértices, sessenta vezes por segundo. Em JavaScript, o coletor de lixo controla o seu orçamento de quadro. Ele não se importa que você esteja no meio de um arrasto. Alguns milissegundos de coleta no momento errado aparecem para o usuário como lag, e lag numa ferramenta de modelagem não é um incômodo: quebra o circuito mental entre mão e forma. Por isso a versão web do SketchUp sempre pareceu, nas palavras dos próprios usuários, “mais lenta e menos capaz” que a versão desktop.
Rust compilado para WebAssembly elimina essa classe inteira de falhas. Você tem memória linear sob seu controle, layout determinístico para os buffers de geometria e nenhum coletor à espreita entre os quadros. Mais importante: não é que o Wasm seja magicamente mais rápido em tudo. Já falamos que o WebAssembly frequentemente perde para JavaScript bem otimizado em trabalhos com muita string e próximos ao DOM. Mas um kernel geométrico é a carga de trabalho oposta: loops apertados sobre grandes arrays planos de f32. É exatamente aí que memória previsível ganha e onde o modelo de objetos do JS mais atrapalha.
A correção, então, não é “deixar o navegador mais rápido”. É “parar de rodar um motor geométrico num runtime projetado para documentos”. O navegador é só o mecanismo de entrega. O que roda dentro dele pode ser código de sistemas.
Lição 2: WebGPU vs WebGL para renderização de CAD, saiba o que você está comprando
O segundo erro é mais sutil: presumir que o WebGL basta porque “um modelador é só triângulos”. Renderizar triângulos sombreados é de fato a parte fácil. Tudo ao redor dos triângulos é onde o WebGL machuca.
Um pouco de história, porque ela explica a API. WebGL é descendente direto do OpenGL, que por sua vez descende do IRIS GL da SGI, uma máquina de estados projetada no fim dos anos oitenta para hardware que não existe mais. Você programa mutando estado global do contexto e torcendo para ter ajustado os botões certos antes de cada draw call. Era uma abstração razoável para 1992. Para uma viewport de CAD, você precisa constantemente de coisas que ele torna desajeitadas: picking na GPU (qual face está sob o cursor?), tesselar faces com furos, calcular espessuras de linha em espaço de tela para as arestas, gerenciar buffers que mudam a cada quadro. Dá para fazer tudo isso em WebGL2, mas você estará parafusando trabalho de formato computacional numa API sem compute shaders e com sincronização implícita em todo lugar.
O WebGPU corrige o modelo, não só a velocidade. Pipelines explícitos em vez de estado global escondido. Storage buffers e compute shaders, então tesselação e picking podem viver na GPU, onde os dados já estão. Um modelo de erros que informa o que você fez de errado em vez de falhar silenciosamente. E, esta é a parte que importa estrategicamente, o crate Rust wgpu implementa essa mesma API sobre Vulkan, Metal e Direct3D. Escreva seu renderizador uma vez com wgpu e ele compila para WebGPU no navegador e para gráficos nativos no desktop. Essa decisão única é o motivo pelo qual o BenchUp consegue distribuir builds para Windows, macOS, Linux e navegador a partir de uma única árvore de código.
A ressalva honesta: o suporte a WebGPU não é universal, e uma ferramenta séria precisa de um caminho de fallback para WebGL2. O BenchUp exige um ou outro. Mas construir primeiro para WebGPU e degradar com elegância é a ordem certa. A ordem inversa é como você acaba arquitetonicamente preso em 1992.
Lição 3: O kernel geométrico não é a parte difícil, a inferência é
Aqui está o erro que acho mais interessante, porque é uma falha de priorização, não de engenharia. Quando desenvolvedores se propõem a clonar um modelador, quase sempre começam pelo kernel geométrico: representações de fronteira, operadores de Euler, robustez de booleanas. É a parte intelectualmente mais séria, então deve vir primeiro. Certo?
Errado, e a história mostra o porquê. Kernels de modelagem sólida são um problema resolvido e commoditizado há décadas: o BRL-CAD fazia geometria sólida construtiva para o Exército dos EUA no fim dos anos setenta, Parasolid e ACIS industrializaram a representação de fronteira nos anos oitenta, e o OpenCASCADE é open source desde 1999. Se um kernel poderoso fosse o produto, um dos muitos modeladores baseados em OpenCASCADE já teria comido o almoço do SketchUp anos atrás. Nenhum comeu. Porque o gênio do SketchUp, quando a @Last Software o lançou de Boulder em 2000, não era poder geométrico. Era o motor de inferência: o jeito como o cursor encaixa em pontos médios, trava nos eixos vermelho, verde e azul e adivinha o plano em que você está desenhando. Os usuários nunca digitam coordenadas. O software encontra a mão onde ela está.
Por baixo, o SketchUp é um modelador de superfície gloriosamente simples: faces e arestas, sem necessidade de sólidos. Push/Pull é só extrudar uma face e costurar as laterais. A complexidade vive na camada de interação, e é onde o KetchUp claramente concentrou seu esforço. A lógica de snap se parece com isto:
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 nessa função é matematicamente profundo. A profundidade está na ordem de prioridade, na tolerância que escala com o zoom e nos trinta microcomportamentos que a fazem parecer telepática em vez de saltitante. Isso são mil horas de ajuste, não mil páginas de teoria de kernel. Se você está construindo um modelador, construa a camada de inferência primeiro e mantenha a geometria embaraçosamente simples até os usuários exigirem mais.
O motor de inferência é o produto. O kernel geométrico é encanamento. Clone o encanamento por último.

Lição 4: Não construa uma UI de CAD com nós do DOM
O quarto erro é o que tem cara de React. A arquitetura padrão para um “app web com canvas” é uma aplicação DOM envolvendo um elemento <canvas>: barras de ferramentas como divs, painéis como componentes, diálogos como portals. Para um CRUD isso é ótimo. Para uma ferramenta de modelagem, você acabou de grudar um motor de layout que invalida estilos e faz reflows imprevisíveis na lateral de um renderizador que precisa de cada microssegundo do seu quadro. Aí você passa a depurar por que o estado de hover da sua barra de ferramentas causa um quadro perdido enquanto você orbita a câmera.
O KetchUp segue o caminho oposto: a interface inteira é desenhada na GPU, e o DOM fica reduzido a um único canvas. É o mesmo movimento arquitetural dos emuladores de terminal acelerados por GPU. Alacritty e companhia deixaram de pedir ao DOM que renderizasse texto célula por célula e passaram a tratar a janela como uma textura. Vimos como isso funcionou bem em a abordagem de atlas de glifos do terminal moderno. O ecossistema Rust torna isso quase de graça: uma GUI em modo imediato como o egui compila para Wasm, renderiza via wgpu e entrega botões, painéis e texto sem um único nó do DOM. Um comentarista do Hacker News, surpreso com quão nativo parecia, destacou especificamente a renderização de texto. Não é coincidência. Texto é onde interfaces sem DOM costumam falhar, e acertar isso é sinal de que a pilha de renderização é realmente sólida.
O trade-off é real, então vamos nomeá-lo: a UI em modo imediato refaz o layout a cada quadro, as ferramentas de acessibilidade pressupõem um DOM, e você abre mão de tudo que o navegador oferece de graça. Para uma superfície de ferramenta com algumas centenas de widgets redesenhados a 60 fps, o custo de recálculo é ruído. O custo de acessibilidade é o que deve mantê-lo honesto, mas é um custo a mitigar, não um motivo para trazer de volta as tempestades de reflow.
Lição 5: Arquivos local-first vencem o aprisionamento na nuvem
Agora o erro que nem é técnico. Quando a Trimble adquiriu o SketchUp do Google em 2012, o produto seguiu lentamente o caminho conhecido: a versão desktop gratuita (SketchUp Make) foi descontinuada, o plano gratuito virou um app web atrás de uma conta, e as licenças perpétuas foram eliminadas em favor de assinaturas que custam centenas por ano. O ressentimento na comunidade não é realmente sobre dinheiro. Hobistas repetidamente dizem que pagariam felizes um preço justo e único. É sobre os termos. Pessoas têm modelos de casas que levaram anos para construir, guardados num formato e num regime de licenciamento que pode ser reprecificado por baixo delas. Um comentarista ainda roda a versão gratuita de 2017 sob WINE em vez de aceitar o novo acordo. Isso não é nostalgia. É uma negociação de reféns.
A solução do KetchUp é quase desafiadoramente antiquada: o salvamento automático vai para o armazenamento do navegador no seu dispositivo, File → Save baixa um arquivo de projeto .ketchup portátil, importações de geometria .skp do SketchUp rodam localmente, e a exportação OBJ está lá quando você quiser sair. Não há servidor. Não há conta. A documentação até avisa, em linguagem simples, que limpar os dados do navegador apaga seus salvamentos automáticos, que é a troca honesta do software local-first, declarada logo de início.
Este é o trecho que quero sublinhar, porque é a lição mais antiga da peça: o formato de arquivo é o aprisionamento, e a interoperabilidade é o pé de cabra. Todo desafiante bem-sucedido de uma ferramenta consolidada começou lendo os arquivos do incumbente. O WordPerfect perdeu para os filtros de importação do Word, não para a lista de recursos. A importação do SketchUp importa mais para a adoção do KetchUp do que qualquer recurso de modelagem isolado jamais vai importar. A exportação OBJ só de geometria (sem materiais) é uma imperfeição aceitável; ela sinaliza que a direção é para fora, não para dentro.
Lição 6: Escreva uma vez em Rust, rode nativamente e na web
O erro final é tratar “a versão web” como um produto separado. Historicamente foi assim: uma base de código nativa em C++, e depois um esforço web paralelo, anos atrás, para sempre inferior. Os usuários percebiam qual era o produto real e qual era a demo.
A pilha sobre a qual o KetchUp roda faz essa distinção evaporar. Rust trata Wasm como alvo de primeira classe. O wgpu fala WebGPU no navegador e Vulkan, Metal e D3D no desktop. O egui roda nos dois lugares sem mudanças. As builds web e nativas não são primas: são o mesmo programa, compilado duas vezes. Não resisto a apontar que essa é a promessa que o Java fez em 1995 finalmente cumprida, por um formato de bytecode sem coletor de lixo e sem ideologia de linguagem acoplada. O WebAssembly teve sucesso como alvo de compilação justamente porque nunca tentou ser uma plataforma em que você escreve. O navegador se tornou discretamente um destino crível para código de qualidade nativa. Vimos isso com jogos de console recompilados estaticamente rodando em abas, e CAD é apenas o próximo gênero a cair.

Há mais uma nuance que vale a pena considerar. Pelas aparências, este projeto foi construído em grande parte com assistência de IA para programação. A comunidade percebeu imediatamente, e a reação foi em sua maioria de dar de ombros e elogiar. Isso combina com um padrão que vários comentaristas nomearam explicitamente: estamos entrando numa era em que construir sua própria ferramenta é uma alternativa realista a aprender a de outra pessoa. Uma única pessoa motivada, armada com Rust, wgpu e um par de IA, agora consegue reproduzir o ciclo central de um produto que uma empresa de capital aberto aluga por centenas por ano. Se essa era te deixa animado ou alarmado provavelmente depende de qual lado da fatura você está.
O KetchUp pode ou não ser o projeto que finalmente dá aos modeladores amadores um lar permanente. Ele é jovem, o núcleo geométrico é simples, e os aficionados do SketchUp com modelos enormes vão encontrar o teto dele rapidamente. Mas como prova de existência, já cumpriu seu papel. O navegador nunca foi fraco demais para CAD. Só estávamos construindo errado: runtime errado, API errada, prioridades erradas, modelo de negócio errado. Corrija essas quatro coisas, e uma assinatura de 300 dólares por ano começa a parecer um imposto sobre a inércia.


