The Future of CAD Is Computed, Not Drawn

The first CAD systems replaced drafting boards with digital screens. The geometry was the same, the tools just moved from physical to virtual. Lines, arcs, and circles drawn on a 2D plane, dimensioned by hand, stored as digital vectors instead of pencil marks.

The second generation added the third dimension. Parametric B-rep modeling, pioneered by Pro/ENGINEER in 1988 and refined by SolidWorks, CATIA, and NX over the following decades, let engineers build 3D solids through a sequence of feature operations: sketch, extrude, revolve, fillet, pattern, Boolean.

This paradigm has dominated engineering design for 35 years. It is mature, powerful, and deeply embedded in industrial workflows. It is also reaching its limits.

The third generation of CAD will not be a better feature tree. It will be geometry that is computed from specifications, evolved by physics, optimized by algorithms, and represented as mathematical functions rather than surface patches. This is not a prediction. The convergence is already happening.

The Historical Arc

Understanding where CAD is going requires understanding where it has been.

Era 1: Digital Drafting (1963-1987)

Ivan Sutherland’s Sketchpad (1963) demonstrated that computers could manipulate geometric objects interactively. The first commercial CAD systems (Computervision, Applicon, Intergraph) digitized the drafting board. The output was 2D drawings, the same deliverable that paper drafting produced, just created more efficiently.

The geometry representation was simple: lines, arcs, and text on layers. There was no solid model, no volume, no mass. The drawing was the design.

Era 2: Solid Modeling (1980-1995)

MAGI’s SynthaVision (1972) and later systems from Spatial Technology (ACIS) and Siemens (Parasolid) introduced constructive solid geometry and boundary representation. For the first time, a computer model represented an actual 3D solid with volume, mass, and surface area.

Pro/ENGINEER (1988) combined B-rep solids with parametric feature trees, establishing the paradigm that still dominates. Every modern feature-based CAD system is a descendant of this architecture.

Era 3: Parametric Feature Modeling (1995-Present)

SolidWorks democratized parametric modeling for mid-market engineers. CATIA extended it to automotive and aerospace scale. NX added advanced surfacing. Fusion 360 brought it to the browser. Each generation improved usability, performance, and integration, but the fundamental representation remained B-rep with a parametric feature history.

The longest-lived architectural assumption in the industry is that geometry is constructed from explicit surfaces.

Era 4: Computed Geometry (Emerging)

The emerging paradigm treats geometry not as a construction but as a computation. The designer specifies what the geometry must do (carry these loads, transfer this heat, fit in this envelope) and the system computes what the geometry should be.

B-rep Limitations

Boundary representation has served engineering well. Its limitations are not bugs but inherent trade-offs of the representation:

Topological Fragility

B-rep solids are defined by the arrangement of faces, edges, and vertices. This topology is exact: surfaces meet at edges, edges meet at vertices, and every face has a well-defined boundary loop. When Boolean operations (union, intersection, difference) modify this topology, the kernel must compute surface-surface intersections, trim surfaces, and rebuild the topological graph.

This computation is numerically challenging. Two surfaces that are nearly tangent produce intersection curves that are nearly degenerate. Surfaces that pass through edge vertices create point-on-edge singularities. Three surfaces meeting at a point create vertex classification ambiguities. Every B-rep kernel carries tens of thousands of lines of special-case logic to handle these degeneracies, and failures still occur.

The practical impact is that complex Boolean operations sometimes fail, feature tree regeneration sometimes breaks, and imported geometry sometimes has “dirty” topology that requires manual repair. These are not software bugs. They are inherent limitations of computing exact surface intersections in finite-precision arithmetic.

Scalability Ceiling

B-rep representation complexity is proportional to geometric complexity. A lattice structure with 10,000 struts has 10,000 surface entities with all their edges and vertices. A metamaterial with periodic unit cells tiled 100 times in each direction generates millions of topological entities. Graded structures where parameters vary spatially require unique geometry for every position.

The representation grows with the design, and operations on large representations become slow. This is not a hardware problem that more memory or faster processors will solve. It is a complexity-class problem: the representation is inherently proportional to the geometric detail.

Abstraction Mismatch

Modern engineering increasingly deals with geometries that are not natural to construct from features. Topology optimization outputs are density clouds. Lattice structures are periodic mathematical functions. Organic shapes from generative design are freeform surfaces. Metamaterials are spatially varying fields. These geometries can be forced into B-rep, but the conversion is lossy, slow, or both.

The engineer thinks in terms of “fill this region with a 30% density gyroid” but the CAD system must represent this as millions of explicit surface patches. The abstraction level of the tool does not match the abstraction level of the design intent.

Five Converging Trends

Five independent trends are converging to create the conditions for the next CAD paradigm:

1. Additive Manufacturing

AM removes the geometric constraints that B-rep was designed around. When any geometry can be manufactured, the representational bottleneck shifts from “what can we build?” to “what can we represent?” Lattice structures, internal channels, graded densities, and consolidated assemblies all push beyond what B-rep handles naturally.

The AM market is growing at 20%+ annually. As it moves from prototyping to production, the volume of geometry that needs implicit or field-based representation grows proportionally.

2. Topology Optimization and Generative Design

Topology optimization is becoming a standard engineering tool, not a research curiosity. Autodesk, Altair, Siemens, and ANSYS all offer integrated topology optimization. The output is a density field that must be interpreted as geometry.

The gap between “optimization result” and “manufacturable CAD model” is where most workflows lose time and fidelity. Bridging this gap requires a geometry representation that natively handles continuous fields.

3. Simulation-Driven Design

The traditional workflow is design-then-simulate: create geometry, mesh it, run FEA/CFD, interpret results, modify geometry, repeat. Simulation-driven design inverts this: the simulation drives the geometry directly. Shape optimization, adjoint-based aerodynamic optimization, and PDE-based shape evolution all produce geometry as the output of a computation.

These workflows need a geometry representation that is compatible with PDE solvers, gradient computation, and continuous optimization. B-rep is not that representation. Implicit fields are.

4. AI and Machine Learning in Design

Generative AI for 3D geometry is advancing rapidly. Diffusion models generate point clouds and implicit fields. Neural radiance fields (NeRFs) and neural signed distance fields represent geometry as neural network outputs. These representations are inherently continuous and implicit.

As AI becomes part of the design workflow (suggesting geometries, interpolating between designs, optimizing for multiple objectives), the geometry representation must be compatible with differentiable computation. Implicit fields are differentiable by construction. B-rep is not.

5. Browser and Edge Computing

WebAssembly enables high-performance computation in the browser. WebGPU brings GPU-accelerated computation to web applications. These technologies make it feasible to run a full geometry kernel on the client, enabling the data sovereignty and offline capabilities that server-dependent approaches cannot provide.

The browser is becoming the universal compute platform. CAD that runs natively in the browser, with full kernel capability, is now architecturally possible.

Geometry-as-Code

The most profound shift is conceptual: treating geometry not as a drawing or a feature tree but as a program.

In traditional CAD, geometry is constructed interactively through GUI operations. The feature tree records the construction history, but it is fundamentally a sequence of manual actions.

Geometry-as-code defines geometry programmatically:

let bracket = sphere(center, radius)
    .smooth_union(box(min, max), blend_radius)
    .difference(cylinder(axis, r))
    .with_lattice(gyroid(cell_size, density_field))
    .constrain(min_wall_thickness(0.5))
    .optimize(minimize_compliance, volume_fraction(0.3));

This code is:

• Parametric by default. Every value is a variable that can be changed.
• Versionable. It lives in Git, can be diffed, branched, and merged.
• Composable. Complex designs are built from reusable components.
• Testable. Geometric properties can be asserted in automated tests.
• Reviewable. Engineering review can examine the design logic, not just the visual result.
• Reproducible. Running the same code always produces the same geometry.

This is not a niche workflow for programmer-engineers. It is the natural endpoint of parametric design. Feature trees are already programs; they are just programs trapped in a GUI with no version control, no testing, no composition, and no review process.

The NeuroCAD Thesis

NeuroCAD is built on the thesis that these five trends are not independent but aspects of a single transition: CAD is moving from explicit construction to implicit computation.

The architecture follows directly:

Signed distance fields as the native geometry representation, because they handle topology optimization outputs, lattice structures, graded materials, and AI-generated geometry without conversion.

E-graph optimization for algebraic simplification and equivalence-preserving transformation of field expressions, because geometry-as-code needs a compiler.

BVH acceleration for real-time field evaluation, because interactive performance is non-negotiable for a design tool.

WebAssembly execution for client-side computation, because data sovereignty and offline capability are architectural requirements, not features.

CRDT collaboration for multi-user real-time editing, because distributed engineering teams need to work concurrently.

Constraint graph (DCG) for parametric relationships, because engineering design is fundamentally constraint-based.

These are not bolt-on features. They are the structural consequences of taking implicit computation seriously as the foundation of a CAD system.

What Changes

If geometry is computed rather than drawn, several things change:

The Designer’s Role

The engineer becomes a specification author rather than a construction operator. Instead of deciding where every fillet goes, the engineer specifies smoothness requirements and lets curvature flow find the optimal filleting. Instead of manually placing lattice struts, the engineer specifies load cases and density bounds and lets the optimizer place material.

This is not replacing the engineer. It is elevating the engineer from construction labor to design intent specification. The engineer’s expertise in requirements, constraints, and trade-offs becomes more valuable, not less.

The Design Review Process

When geometry is code, design review becomes code review. Parametric relationships are readable. Constraint logic is inspectable. Design intent is explicit in the source, not implicit in a feature tree that requires replaying to understand.

Two engineers can diff their geometric models, see exactly what changed, and discuss the engineering rationale. This is impossible with file-based B-rep models where “open it and look” is the only review method.

The Supply Chain Interface

When geometry is a field function, the exchange format can be the function itself, not a tessellated approximation. A supplier receives the signed distance field and evaluates it at whatever resolution their manufacturing process requires. No tessellation artifacts, no resolution-dependent quality loss, no “STL is not good enough” conversations.

For B-rep interchange, the conversion pipeline (SDF to STEP) remains available. But for the growing number of AM supply chains that consume mesh directly, field evaluation at arbitrary resolution is strictly superior.

The Optimization Loop

When geometry is differentiable, optimization can compute gradients of performance metrics with respect to design parameters. Adjoint sensitivity analysis, which is standard in CFD shape optimization, becomes applicable to general CAD geometry. The optimizer does not just evaluate design variants; it computes the gradient and steps directly toward the optimum.

This transforms optimization from “try 1,000 random variants and pick the best” to “compute the direction of improvement and take one step.” The difference in convergence speed is orders of magnitude.

What Does Not Change

Some things remain constant regardless of the representation:

Engineering judgment. No geometry representation eliminates the need for experienced engineers who understand failure modes, manufacturing realities, and system-level trade-offs.

Physical testing. Computed geometry still needs physical validation. Simulations are models, not reality. The prototype shop is not going away.

Standards and certification. Aerospace, medical, and automotive certification processes require documented evidence trails. The documentation is different (code commits instead of ECN packages) but the rigor is the same.

Human creativity. Defining what to build remains a creative act. The CAD system computes how to achieve the specification, but the specification itself comes from human insight, customer needs, and engineering intuition.

The Transition Is Not Instant

B-rep CAD will remain dominant for years. The installed base of SolidWorks, CATIA, and NX is enormous. The training investment, macro libraries, and institutional knowledge built around these tools represent decades of accumulated value. No technology transition, no matter how compelling, replaces this overnight.

The transition will happen at the edges first: additive manufacturing workflows where implicit geometry is natural, topology optimization post-processing where field representations eliminate conversion steps, multi-physics optimization where differentiable geometry enables gradient-based methods.

Over time, these edges expand. As AM becomes a production process rather than a prototyping novelty, as AI-generated geometry moves from research to production, as simulation-driven design becomes the norm rather than the exception, the proportion of engineering work that benefits from computed geometry grows.

The Inevitable Conclusion

CAD began as digital drafting: drawing lines on a screen instead of paper. It evolved to digital construction: building solids from features instead of drawings. The next evolution is digital computation: specifying intent and computing geometry instead of constructing it.

This is not a radical prediction. It is the logical consequence of five trends that are already well underway. The question is not whether CAD will become computational. The question is which platform makes the transition first and captures the workflows that existing tools cannot serve.

NeuroCAD’s bet is that the answer starts with implicit geometry, runs on WebAssembly, optimizes with e-graphs, collaborates with CRDTs, and treats every geometric operation as a computation rather than a construction.

The future of CAD is computed, not drawn. The transition has already begun.