KetchUp: an open source SketchUp alternative built in Rust
I opened a browser tab and, without installing anything, started pulling faces on a cube like I would in SketchUp. This is KetchUp, an open source alternative to SketchUp written in Rust and rendered with WebGPU. The name is an obvious joke, but the project carries more weight than the joke. You can try it right now at ketchup3d.github.io/app.
I'm not an architect or a 3D modeler. I'm a web dev. And that's exactly why the project caught my eye: it's practical proof that you can run "desktop" software in the browser without apologizing for performance.
So what is KetchUp?
It's a 3D modeler with that SketchUp feel: you draw lines, close faces, and extrude volumes. It's the "push and pull" modeling that made SketchUp a tool for architects, woodworkers, and anyone who just wants to plan a kitchen remodel.
The difference comes down to three things:
- Open source. You can read it, fork it, and contribute.
- Rust at the core. The geometry logic runs in a compiled language, with fine control over memory.
- WebGPU for rendering. The graphics card is accessed through the modern browser graphics API, not the old WebGL.
And all of it is hosted on GitHub Pages. A static file. No server, no account, no subscription.
A fair warning: it's a young project. Don't expect the component library, the plugins, or the years of polish of a commercial tool. Treat it as what it is: a promising project you can follow and help shape.
Why an open source SketchUp alternative matters
SketchUp has a curious history. It was born in a startup, went through Google, which gave away a pretty generous free version, and was later sold to Trimble. Over time, the model shifted to subscriptions, and the free version became more limited and restricted to non-commercial use.
I'm not saying Trimble is the villain. Companies need to make money. But anyone who uses the tool for work knows the feeling: your projects are stuck in a format and a license that someone can change tomorrow.
This is where open source really makes a difference. Not because it's free, but because it's predictable. If the maintainer disappears, the code is still there. If the project's direction goes somewhere you don't like, someone forks it. Blender is the classic example: it spent years being treated as a "toy" and today it's used in production at big studios.
Free software doesn't guarantee the project will succeed. It guarantees nobody will lock the door with you inside.
KetchUp is still far from being the Blender of architectural modeling. But that's the seed.
Rust and WebGPU: why this stack makes sense
Now the part that matters for people who write code.
3D modeling has two bottlenecks. The first is geometry: computing intersections, splitting faces, keeping the topology consistent when you push a face and it touches another one. It's heavy math, full of edge cases and treacherous floating point. The second is rendering: drawing thousands of polygons at 60 frames per second while you orbit the camera.
For the first, Rust compiled to WebAssembly is a sensible choice. You get near-native performance, with no garbage collector pausing the interaction in the middle of a mouse drag. And the compiler forces you to think about who owns each piece of the mesh, which is great for a data structure full of cross-references between vertices, edges, and faces.
For the second, WebGPU is the natural path. WebGL is based on OpenGL ES, an API with decades of baggage. WebGPU was designed on top of modern APIs (Vulkan, Metal, Direct3D 12) and exposes things like compute shaders, which WebGL simply doesn't have.
In the Rust ecosystem, the most common path for this is wgpu, a library that speaks WebGPU in the browser and Vulkan, Metal, or DirectX on desktop. A project with this stack can, in theory, ship the web app and the native app from the same code. I don't know if KetchUp takes advantage of that yet, but the stack allows it.
A simplified snippet of what initialization looks like with wgpu gives you a sense of the abstraction level:
let instance = wgpu::Instance::default();
let adapter = instance
.request_adapter(&wgpu::RequestAdapterOptions::default())
.await
.expect("no compatible GPU");
let (device, queue) = adapter
.request_device(&wgpu::DeviceDescriptor::default(), None)
.await
.unwrap();
Is it verbose? Yes. But it's verbose in the right way: explicit about what it's asking the graphics card for.
What this changes for TypeScript front-end devs
You might be thinking: "cool, but I build dashboards in React, not 3D modelers". Fair. But the KetchUp pattern applies to a lot of what we build.
The architecture usually looks like this:
- A Rust/Wasm core handling the heavy, deterministic work.
- A JS/TS interface handling buttons, panels, and shortcuts.
- A well-defined boundary between the two, with few calls and large data passed through buffers.
That third point is where most people get it wrong. Calling a Wasm function on every mousemove and passing JS objects is asking to lose all the performance advantage. The right way is to send short commands and let the core do the work:
// bad: serializes the entire mesh every frame
engine.updateMesh(JSON.stringify(mesh))
// better: small command, state stays in Wasm
engine.pushPull(faceId, distance)
I've seen this pattern solve real problems in image editors, map viewers, and processing large spreadsheets in the browser. If your React app stutters while computing something on the main thread, the question "should this be Wasm?" deserves at least five minutes of thought. Sometimes the answer is "no, just move it to a Web Worker". That already helps.
Can you use KetchUp instead of SketchUp today?
Short answer: for professional work on a deadline, probably not yet.
Long answer: it depends on what you need. If you want to model a piece of furniture, plan a room, or just play around with 3D without installing anything, it's worth opening and trying. If you depend on importing .skp files from clients, specific plugins, or generating technical drawings, the commercial tool still wins easily.
Then there's the browser question. WebGPU is already available in recent versions of Chrome and Edge, and arrived in Safari and Firefox more recently, but support still varies by operating system and driver. If it opens to a black screen, that's probably why. Test it in an up-to-date Chrome before concluding the project is broken.
A few things I'd check before adopting any young tool like this one:
- How often commits land and how many people maintain the project.
- Whether there's an open, documented file format to export your work.
- Whether issues get answered.
The second one is the most important. An open source tool that saves to a closed, poorly documented format just trades one prison for another.
My take on KetchUp
I think KetchUp matters more as a signal than as a product. A few years ago, a decent 3D modeler running in a tab, served as a static file, would have been a conference demo. Today it's a community project on GitHub Pages.
That says a lot about where the web is heading. The line between "desktop app" and "website" has gotten too thin to justify an installer in most cases. And anyone who knows TypeScript and is willing to learn a bit of Rust is in a great position to build this next wave of tools.
My bet: in two years, half the creative tools you use will have a Wasm core and you won't even notice. The other half will keep asking you to download a 2 GB installer and restart your computer. I'm not sure which one will annoy you more.
If you enjoy this kind of heavy web experiment, take a look at what I've been building in my projects.
LinkedIn summary
I opened a browser tab and, without installing anything, I was pulling faces on a cube just like in SketchUp. It's KetchUp: an open source 3D modeler written in Rust and rendered with WebGPU, hosted as a static file on GitHub Pages. No server, no account, no subscription. It's still young and won't replace a commercial tool for work on a deadline. But it's a clear sign: the line between "desktop app" and "website" has gotten really thin. For web devs, the lesson holds even outside 3D: keep the heavy work in a Wasm core, send short commands, and stop serializing the whole world every frame. And open source matters less for being free and more for being predictable. Nobody locks the door with you inside. I wrote about it on the blog. If you're into heavy web stuff, drop by and tell me what you think. #Rust #WebGPU #WebAssembly #OpenSource #WebDevelopment