The Installation Problem

Traditional CAD software comes with a long list of prerequisites: a specific operating system (usually Windows), a qualified GPU, a license server, and an IT department to manage updates. For a large company, this is manageable overhead. For a startup, a freelance engineer, a university student, or a manufacturing partner who needs to review a design once, it is a barrier.

The browser has already replaced installed software for email, documents, spreadsheets, video conferencing, and project management. Engineering tools are the next frontier.

What Makes Browser CAD Possible Now

Two technologies have removed the performance gap that previously made browser-based CAD impractical:

WebAssembly (WASM)

WebAssembly is a binary instruction format that runs in the browser at near-native speed. Code written in C, C++, or Rust can be compiled to WASM and executed in any modern browser without plugins.

For a CAD kernel, this means the geometry evaluation engine — the computationally intensive core — runs client-side, in the browser, at speeds comparable to a native application. There is no round-trip to a server for every operation. The constraint solver, the field evaluator, and the mesh extraction pipeline all execute locally.

WASM also provides:

Deterministic execution: the same input produces the same output on every platform
Sandboxed security: the kernel runs in the browser sandbox with no access to the host filesystem unless explicitly granted
Instant updates: refreshing the page loads the latest version of the kernel, with no installer or update manager

WebGPU

WebGPU is the successor to WebGL, providing low-level GPU access from the browser. It exposes compute shaders, which are essential for parallel field evaluation, ray marching, and mesh generation.

For SDF-based CAD, WebGPU is transformative. Evaluating a signed distance field across a volumetric grid is embarrassingly parallel — every point can be evaluated independently. A WebGPU compute shader can evaluate millions of field samples per frame, enabling real-time visualization of implicit geometry directly in the browser.

WebGPU also supports:

Compute pipelines: general-purpose GPU computation, not just rendering
Storage buffers: large data transfers between CPU and GPU
Shader compilation caching: subsequent visits load faster

Client-Side vs. Server-Side Architecture

Browser-based CAD can be implemented in two fundamentally different ways:

Server-Side Rendering (Streaming)

The CAD kernel runs on a server. The browser receives a video stream or pre-rendered geometry. This approach works for any device with a browser, even a tablet with a weak GPU.

Drawbacks:

Latency: every interaction (rotate, pan, edit) requires a network round-trip. At 50ms latency, the experience feels sluggish. At 200ms, it is unusable for detailed modeling.
Server cost: every concurrent user requires server GPU time. Scaling to thousands of users means thousands of GPU instances.
Offline capability: none. Without a network connection, the tool does not function.

Client-Side Computation (WASM + WebGPU)

The CAD kernel runs entirely in the browser. Geometry evaluation, constraint solving, and rendering all happen on the user’s machine.

Advantages:

Zero latency: all interactions are local. The experience is indistinguishable from a native application.
Zero server cost for computation: the server only stores files and manages collaboration. No GPU instances needed.
Offline capable: once loaded, the application can function without a network connection.
Privacy: design data never leaves the user’s machine unless explicitly shared.

The trade-off is that the user’s machine must be capable enough. Modern laptops and desktops with integrated GPUs handle this well. Chromebooks and older tablets may struggle with complex models.

What a Zero-Install Workflow Looks Like

Consider a typical engineering scenario: a design review with a manufacturing partner.

Traditional workflow:

Export the model to STEP format
Email the file (or upload to a shared drive)
Partner installs a STEP viewer (or buys a CAD license)
Partner opens the file, struggles with display settings
Feedback happens over email with annotated screenshots

Browser-based workflow:

Share a link
Partner opens the link in any browser
The model loads with full 3D interaction
Partner annotates directly in the viewer
Comments are synchronized in real time

The second workflow eliminates every friction point. No file conversion, no software installation, no compatibility issues, no license management.

Security Considerations

Running a CAD kernel in the browser raises legitimate security questions:

Intellectual property: if geometry is evaluated client-side, the design data is on the user’s machine. For the design owner, this is actually an advantage — data stays local. For collaboration, encryption and access controls at the application layer manage sharing.
Code protection: WASM binaries can be reverse-engineered, but the effort is comparable to reverse-engineering a native binary. Obfuscation and server-side licensing validation provide additional layers.
Browser sandbox: WASM runs in a sandboxed environment. It cannot access the filesystem, network, or other browser tabs without explicit permission. This is more secure than a native application with full OS access.

Limitations to Acknowledge

Browser-based CAD is not a silver bullet:

Large assemblies: models with thousands of parts and millions of faces push browser memory limits. Progressive loading and level-of-detail techniques help, but a 10GB assembly is not practical in a browser today.
Legacy integrations: many engineering workflows depend on COM automation, DDE, or local file system hooks. Browser applications cannot replicate these integrations.
Peripheral access: 3D mice (SpaceMouse), digitizers, and custom input devices require native drivers. Browser APIs for HID devices exist but are limited.
Certified workflows: aerospace and automotive industries require validated software environments. Browser-based tools must meet the same certification standards as native tools, which is possible but adds compliance overhead.

Where NeuroCAD Fits

NeuroCAD compiles its Rust-based geometry kernel to WebAssembly, enabling full client-side evaluation of signed distance fields in the browser. The visualization pipeline uses WebGPU compute shaders for parallel field evaluation and real-time ray marching. The result is a CAD environment that runs entirely in the browser, with no installation, no plugins, and no server-side GPU rendering.

This architecture means that opening a NeuroCAD project is as simple as opening a URL. Design reviews, collaboration with manufacturing partners, and access from any machine are all enabled by default, without any infrastructure overhead.

The Trajectory

Browser-based CAD is not a future prediction — it is happening now. Onshape proved that cloud CAD is viable. WebAssembly and WebGPU are proving that client-side computation can match native performance. The combination of these technologies eliminates the last argument for mandatory installed software: performance.

The engineering tools that will define the next decade are the ones that meet engineers where they are — in a browser, on any device, with zero friction.

Browser-Based CAD: No Install Required