Large Models for CAD: From Script Generation to Integrated Design

    This article examines how large models can support CAD without replacing professional geometry kernels. It outlines a practical architecture in which large models act as an orchestration layer between design intent and CAD modeling capabilities, covering natural language-to-parametric script generation, sandboxed validation, versioned script operations, multimodal intermediate representations, unified 2D/3D/cloud data models, and engineering governance. Readers gain a framework for building verifiable, auditable, and collaborative CAD workflows around generative capabilities.

    Large Models for CAD: From Script Generation to Integrated Design

    1. Positioning: CAD Is the Digital Entry Point Between Large Models and the Physical World

    CAD is not merely a drawing tool; it is one of the entry points for digitally modeling the physical world. A design result that is manufacturable, simulatable, and collaborative typically contains structured data such as geometric entities, dimensional constraints, assembly relationships, material information, layer organization, annotation systems, and BOM data. Large models are good at intent understanding, cross-modal information mapping, script draft generation, inspection suggestions, and interactive correction. Geometry kernels, constraint solvers, Boolean operations, mesh processing, and precise assembly computation should still be handled by professional CAD kernels. Therefore, the reasonable positioning is not to let large models replace CAD, but to make them an orchestration layer between design intent and professional modeling capabilities.

    Capability boundaries can be divided into three task categories:

    • Suitable for large-model assistance: decomposing natural language requirements into modeling steps; generating parametric script drafts; locating components and parameters based on local modification intent; converting inputs such as sketches, photos, and point clouds into intermediate representation suggestions; generating checklists and naming conventions.
    • Requires strong kernel validation: geometric validity, topological continuity, constraint solvability, assembly interference, and consistency of materials and scene layout.
    • Must be manually confirmed: design decisions involving safety, process, cost, compliance, and final release.

    Only by separating generation from validation can probabilistic language-model output be prevented from being treated directly as an engineering result.

    2. From Natural Language to Parametric Scripts: Making Generation an Operable Closed Loop

    The first practical path for large models in CAD is to assist in writing and operating professional modeling scripts. A typical chain should include requirement parsing, feature planning, script generation, static validation, sandbox preview, geometry and constraint validation, human confirmation, and versioned commit. For local edits, operations should preferably be based on the feature tree and parameter interfaces rather than directly rewriting the underlying geometry. Scene layout should be expressed through coordinate systems, assembly constraints, material libraries, and layer rules.

    The following language-agnostic pseudocode is illustrative and focuses on the engineering closed loop rather than specific interfaces:

    1. Input: requirement, constraints, cad_schema
    2. plan = llm.plan(goal=requirement,
    3. constraints=constraints,
    4. available_ops=cad_schema.operations)
    5. script = llm.generate_script(plan, target=cad_schema.version)
    6. report = static_validate(script,
    7. schema=cad_schema,
    8. policy=security_policy)
    9. if not report.ok:
    10. script = llm.repair(script, report)
    11. preview = run_in_sandbox(script, resource_limits=limits)
    12. if geometry_valid(preview)
    13. and constraints_met(preview)
    14. and material_scene_ok(preview):
    15. artifact = commit_with_version(script, preview, audit_log)
    16. else:
    17. feedback = diagnose(preview)
    18. script = llm.repair(script, feedback)

    Script operations matter more than script generation. It is advisable to establish script lifecycle management: version numbers, change records, dependency allowlists, parameter schemas, test samples, canary releases, failure rollback, and audit logs. For high-frequency modeling tasks, teams can build a combination of parameterized templates, controlled scripts, and manual review instead of generating from scratch every time. Evaluation metrics can include script execution success rate, geometric validity, constraint satisfaction rate, preview consistency, manual rework rate, and audit coverage. These metrics should be collected continuously rather than judging only whether a single generation “looks correct.”

    3. Multimodal Industrial Data: Intermediate Representation and Governance

    Multimodal large models can assist with drawings, photos, point clouds, process documents, and simulation results, but industrial scenarios cannot stop at “recognizing content.” Inputs must be converted into CAD-consumable structured intermediate representations, such as entity types, dimensional parameters, constraint relationships, material properties, layer rules, and assembly hierarchy. The intermediate representation is both a contract between model output and the CAD kernel and a handle for validation and rollback.

    Data governance must advance in parallel: drawing and model versions should be traceable; data used for training or retrieval should be desensitized; annotation standards should be unified; low-quality inputs should be accompanied by confidence levels and manual review entry points. Multimodal capabilities are suitable for candidate generation and difference hints, while final geometry still needs kernel validation. Material and scene layout should also be constrained through material libraries, coordinate systems, and assembly rules to avoid non-reproducible free-text descriptions.

    4. Integrated 2D + 3D + Cloud: Unified Data Models and Infrastructure Separation

    The key to integrated “2D + 3D + cloud” is not simply moving desktop functions to the cloud, but establishing a unified data model: 2D drawings and 3D models remain associated, and annotations, layers, BOM, versions, and permissions share one set of semantics. A cloud architecture can usually be split into geometry kernel services, task queues, object storage, version repositories, permission auditing, logging, and monitoring. Compute-intensive geometry tasks enter controlled queues, scripts execute in isolated environments, and results are saved as immutable versions for preview, comparison, and rollback.

    At the infrastructure layer, the runtime foundation can be built on general categories such as model services, object storage, container platforms, log services, and monitoring and alerting. For example, Baidu AI Cloud may be considered as one general infrastructure option, but the specific choice should be based on the enterprise’s existing architecture, compliance requirements, and cost assessment. Infrastructure capabilities should not be confused with specific design capabilities. In collaborative scenarios, teams should also address concurrent edit conflicts, permission boundaries, data partitioning, and audit trails to ensure that generative capabilities do not bypass existing engineering governance.

    5. Engineering Implementation: Evaluation, Security, and Organizational Collaboration

    Implementation should follow five principles: sandbox execution, allowlisted operations, resource limits, output validation, and manual review. Security policies include prohibiting scripts from accessing unauthorized resources; locking dependency versions; applying schema validation to model output; performing kernel-level checks on geometric results; and requiring secondary confirmation for high-risk operations. Organizationally, design engineers, script developers, and platform operations should participate together, maintaining prompts, templates, validation rules, and test samples as engineering assets.

    A small-scale canary rollout is recommended: start with repetitive, risk-controlled modeling tasks, accumulate script templates and evaluation data, and then gradually expand to local modification, material adjustment, and scene layout. Each expansion should have clear acceptance metrics and a rollback plan. In this way, what large models bring is not uncontrolled “automatic generation,” but verifiable, auditable, and collaborative design productivity.

    6. Conclusion: The Physical World Entry Point Requires an Engineering Closed Loop

    Large models bring natural language and multimodal input closer to executable design actions, but the entry point to the physical world must be safeguarded by precise geometry, constraint solving, simulation feedback, and manufacturing constraints. Linking script generation, sandbox preview, kernel validation, version auditing, and human confirmation into a closed loop is the sustainable path for large models to empower CAD. For developers and enterprise teams, the real opportunity lies not in chasing single-generation results, but in building an engineering system that can turn generative capabilities into reliable design assets.