NeuroCAD vs Onshape: Browser CAD Battle

Browser-based CAD has moved from a novelty to a legitimate engineering workflow. Two platforms occupy very different ends of the architectural spectrum: Onshape, the SaaS pioneer that brought parametric modeling to the browser in 2015, and NeuroCAD, the newcomer built on implicit geometry and client-side WebAssembly computation. Both run in a web browser. Almost everything else is different.

This article breaks down architecture, performance characteristics, collaboration models, data ownership, and feature sets. No marketing. Just engineering trade-offs.

Architecture: Server-Side vs Client-Side

The most fundamental difference between these two platforms is where computation happens.

Onshape: Server-Side Kernel

Onshape runs a Parasolid-derived B-rep kernel on its cloud servers. When you create a fillet or extrude a profile, the browser sends the operation to a remote server farm. The server computes the new geometry, tessellates it, and streams the result back as triangulated mesh data for WebGL rendering.

This architecture has clear strengths:

• Consistent performance regardless of client hardware. A Chromebook performs identically to a workstation because the browser is just a display layer.
• No installation, no updates, no hardware requirements beyond a modern browser and decent internet.
• Version control built-in because the server owns the model state.

It also has inherent weaknesses:

• Latency on every operation. Every modeling action requires a network round trip. On a 50 ms connection, each fillet request adds at minimum 100-200 ms before you see results. On high-latency connections, the delay becomes disruptive.
• Server cost scales with usage. More users, more operations, more compute cost for the vendor. This cost pressure is ultimately passed to customers.
• Offline work is impossible. No connection, no CAD.
• Data residency is non-negotiable. Your geometry lives on PTC’s servers, in their chosen data centers.

NeuroCAD: Client-Side Kernel via WebAssembly

NeuroCAD takes the opposite approach. The entire implicit geometry kernel compiles to WebAssembly and executes in the user’s browser. Field evaluation, constraint solving, meshing, and rendering all happen on the client machine.

Strengths of client-side execution:

• Zero-latency modeling. Operations execute locally. There is no network round trip for geometry computation. On modern hardware, SDF field evaluation at interactive resolution takes single-digit milliseconds.
• Offline-capable. Once the application is loaded, the kernel runs without a server connection. Service workers cache the WASM binary and application shell.
• Data stays on the client. Geometry never leaves the user’s machine unless explicitly shared. This is a fundamental data sovereignty advantage.
• Marginal cost of computation is zero for the vendor. Users bring their own compute. This enables aggressive pricing.

Weaknesses:

• Performance depends on client hardware. A 2018 Chromebook will not match a 2024 workstation. WebAssembly is fast, but it runs within browser sandbox constraints.
• WASM binary size. The compiled kernel binary must be downloaded on first load. Aggressive code splitting and caching mitigate this, but cold starts are measurably slower than a thin-client approach.
• WebGPU maturity. GPU-accelerated field evaluation depends on WebGPU, which is still stabilizing across browsers.

Geometry Representation: B-rep vs Implicit

Onshape uses boundary representation, the same paradigm that has dominated CAD for 40 years. Geometry is defined by explicit surfaces, edges, and vertices. Boolean operations compute surface-surface intersections and stitch the result into a new solid.

NeuroCAD uses signed distance fields. Every primitive is a continuous scalar function over 3D space. Boolean operations are algebraic compositions of these functions: union is min(a, b), intersection is max(a, b), smooth union blends with a polynomial kernel. There are no surface-surface intersection calculations, no edge degeneracies, and no topology repair heuristics.

What This Means in Practice

Filleting. In B-rep, a fillet rolls a ball along an edge and trims/extends adjacent surfaces. Edge chains, tangent discontinuities, and multi-face convergence create failure cases. In SDF, a fillet is a smooth-minimum composition that naturally handles arbitrary topology.

Lattice structures. B-rep lattice generation requires creating thousands of explicit solid struts and Boolean-unioning them together. This is computationally explosive. In SDF, a lattice is a periodic field function evaluated everywhere. The representation cost is constant regardless of lattice density.

Organic shapes. B-rep subdivision surfaces approximate organic forms but remain fundamentally piecewise. Implicit fields are naturally smooth and continuous, making them native to organic modeling.

Interoperability. B-rep has mature exchange formats: STEP, IGES, Parasolid XT. Implicit geometry must be converted to B-rep for downstream consumption. This conversion pipeline is non-trivial and introduces approximation. Onshape wins here on ecosystem maturity.

Collaboration Models

Onshape pioneered real-time CAD collaboration. Multiple users can edit the same model simultaneously. The server arbitrates changes through a version control system inspired by Git branching. This is a genuine innovation and remains Onshape’s strongest competitive advantage.

NeuroCAD approaches collaboration differently. Since the kernel runs client-side, real-time collaboration requires a synchronization protocol rather than a shared server computation. The platform uses Conflict-free Replicated Data Types (CRDTs) to merge concurrent edits to the constraint graph without server arbitration. Each user’s local kernel evaluates geometry independently, and the CRDT layer ensures eventual consistency of the parametric model.

Both approaches support branching and merging, but the failure modes differ. Onshape’s server-mediated model guarantees a single source of truth at all times. NeuroCAD’s CRDT model allows offline divergence and later reconciliation, which is more flexible but requires deterministic merge semantics for geometric operations.

Feature Comparison Matrix

Capability	Onshape	NeuroCAD
Parametric sketching	Full 2D constraint solver	Full 2D constraint solver
Feature history	Linear timeline with rollback	DAG-based replay graph
Sheet metal	Yes	Planned
Assemblies	Full, with in-context editing	Implicit assembly via field composition
Drawings / 2D output	Yes	Planned
Simulation	Via third-party apps (Ansys, etc.)	Built-in SDF field analysis
Lattice / infill	Via third-party apps	Native TPMS lattice generation
Topology optimization	Via third-party apps	Native field-driven optimization
STEP export	Native	Via marching-cubes + B-rep fitting
Offline mode	No	Yes
API / scripting	FeatureScript	Geometry-as-code Rust DSL
Mobile support	Yes (viewer)	Progressive Web App

Data Ownership and Residency

This is increasingly a deciding factor for European enterprises and defense contractors.

Onshape stores all model data on PTC’s cloud infrastructure, primarily hosted in AWS regions. Users cannot choose data center locations. PTC’s terms of service govern data handling, and the US CLOUD Act applies to data stored by US-headquartered companies regardless of server location.

NeuroCAD’s client-side architecture means geometry data exists only in the user’s browser memory and local storage by default. Cloud synchronization is opt-in and can be directed to user-specified infrastructure. For organizations subject to GDPR, ITAR, or national security regulations, this is a material difference.

Pricing Philosophy

Onshape charges per-seat subscription fees. As of 2026, professional seats start around $1,500/year. The server compute cost makes aggressive pricing difficult because every active user consumes cloud resources.

NeuroCAD’s client-side computation model decouples active usage from server cost. The vendor’s infrastructure only handles authentication, collaboration sync, and optional cloud storage. This enables dramatically lower per-seat pricing and makes a generous free tier commercially viable.

Performance Benchmarks

Direct comparison requires careful methodology because the platforms solve geometry differently. Nevertheless, some operational metrics are measurable:

Operation latency. For a simple fillet on a 50-face model, Onshape typically completes in 300-800 ms including network latency on a typical broadband connection. NeuroCAD’s local field evaluation completes the equivalent smooth-min composition in 5-20 ms on modern hardware.

Large model handling. Onshape handles assemblies with thousands of parts because the server has enterprise-grade memory and compute. NeuroCAD’s WASM environment is constrained by browser memory limits (typically 4 GB), though hierarchical BVH acceleration and level-of-detail field evaluation extend practical limits significantly.

Cold start. Onshape loads a model by streaming tessellation data from the server, typically 2-5 seconds for a moderate model. NeuroCAD must load the WASM kernel binary (~3 MB compressed) on first visit, then reconstruct the field graph from the saved parametric state, typically 1-3 seconds after the binary is cached.

Who Should Choose What

Choose Onshape if you need a proven, mature parametric CAD with extensive third-party integrations, 2D drawing output, and sheet metal today. If your team already uses PTC products or requires enterprise-grade PLM integration, Onshape fits naturally.

Choose NeuroCAD if you work with organic geometry, lattice structures, or topology optimization as core workflows. If data sovereignty is a hard requirement, if offline capability matters, or if you are designing for additive manufacturing where implicit geometry is a natural fit.

The Honest Summary

Onshape proved that professional CAD works in a browser. That was a genuine breakthrough. But its server-side architecture carries fundamental trade-offs in latency, data ownership, and cost structure.

NeuroCAD asks a different question: what if the browser is not just a display layer but the actual compute engine? Client-side WebAssembly execution, implicit geometry, and CRDT collaboration represent a fundamentally different architecture. It is not a clone of Onshape with a different logo. It is a different answer to the question of how engineers should create geometry.

Both platforms will continue to evolve. The interesting competition is not feature-for-feature parity but which architectural foundation better serves the next decade of engineering workflows.