FreeCAD Plumbing Designer

Big Deal

Study this thread, which describes the steps for full CAD automation of design using part libraries. This applies to generating modules, assemblies, and final modifications - fully automated by schemas and compilers. One just runs compilers to regenerate new iterations of design. This is based on plumbing, which has an extra layer of complexity over structure in terms of more complicated mating surfaces and part orientations.

https://chatgpt.com/share/69784c9d-969c-8010-8eea-339e43a4811d

Concept 1

This is a concept procedure for complete CAD automation -

• I can generate schemas for all plumbing library parts, parametrized.
• Schemas are compiled, parts generated in CAD.
• CAD library can be uploaded to Chat
• Chat generates an assembly schema, whene I provide the parts and orientations in human language.
• I compile the schema for final assembly.
• To place in the house - i provide human languege for geometry - where plumbing starts and ends. This is a structured “constraints + adjustables” spec.
• I upload the full house file
• Chat provides a compilable schema which generates the final insertion of plumbing into house.
• Chat provides a compiler.
• I run compiler locally, providing CAD file + constraint schema.
• I get a final CAD file- which shows properly in FreeCAD
• From here I can get technical drawings and BOM automatically.

Declarative Plumbing CAD Pipeline (Schema → Assembly → Installation)

This document defines the canonical, robust process for designing, assembling, and installing plumbing systems using parametric schemas, automated compilation, and CAD backends (e.g. FreeCAD).

The system treats plumbing as a compiled artifact, not a hand-edited drawing. This procedure applies to all modules/systems, not just plumbing.

1. Generate schemas for all plumbing library parts (parametric)

Each plumbing part is defined by a long-lived, design-time schema.

Each part schema includes:

• Parametric dimensions (length, diameter, schedule, etc.)
• Named ports defined as Local Coordinate Systems (LCS / Datum CS)
• A clear part interface contract (required ports, parameters, orientation rules)

This is the part definition layer.

The schema is the source of truth. Geometry is not edited directly.

2. Compile schemas → generate CAD parts

Part schemas are compiled into CAD artifacts (e.g. .FCStd).

• Compiled CAD parts are authoritative library artifacts
• They are disposable and fully regenerable
• No manual edits are required or expected

Schema = source CAD file = compiled artifact

3. CAD library provided to Chat

Canonical part definitions are provided to Chat via:

• Representative .FCStd examples
• Or a subset of parts plus the formal part interface contract

Chat uses these to:

• Learn port names and conventions
• Validate compatibility
• Generate correct assembly logic

The full library does not need to be re-uploaded once conventions are fixed.

4. Assembly topology schema generated from human language

Human-language instructions such as:

Use a 90° elbow, connect a 10-inch pipe to each side, then a tee.

are translated into a topology schema containing:

• Instance IDs
• Part types (from the library)
• Port-to-port connections
• Default parameters
• Optional roll/orientation rules

This schema defines pure topology. There is no site placement or house context at this stage.

5. Compile topology schema → local assembly

The topology schema is compiled into a local plumbing assembly:

• All parts are instantiated
• All ports are mated
• The assembly exists in its own local coordinate frame

This assembly is:

• Reusable
• Portable
• Independent of any specific building

6. Provide installation geometry constraints (human language → structured spec)

To place the plumbing in a building, installation constraints are provided, including:

• Start penetration pose (location + direction)
• End penetration pose (location + direction)
• Slope requirements (e.g. gravity drainage)
• Declaration of adjustable components (pipes, slip joints, telescoping sections)

This becomes the structured constraints + adjustables specification.

Human language is acceptable; it is compiled into a formal constraint schema.

7. Upload full house CAD file

The house CAD model provides:

• Real geometry
• Wall and floor reference frames
• Penetration locations

The plumbing assembly remains independent.

Plumbing is not edited into the house; it is placed into the house.

8. Generate solved assembly schema for final insertion

Using:

• The topology schema
• The constraints + adjustables spec
• The house geometry

Chat produces:

• A solved assembly schema including:
  • Root placement transform
  • Solved pipe lengths
  • Resolved elbow rolls (if required)
• Or directly produces a FreeCAD Python macro (compiler output)

At this stage, the system is fully determined and unambiguous.

9. Run compiler locally

The compiler is executed locally with:

• Part library CAD files
• Solved assembly schema
• House CAD file

This ensures:

• Determinism
• Local control of execution
• Isolation from CAD version differences

This is the correct trust boundary.

10. Generate final CAD assembly

The output is a final CAD file that:

• Opens correctly in FreeCAD
• Is fully parametric
• Is regenerable
• Contains no broken constraints

The plumbing is correctly placed within the house model.

11. Generate downstream artifacts automatically

Because:

• Parts are structured
• Assemblies are explicit
• Ports and parameters are known

The following are generated automatically:

• Technical drawings
• Bills of Materials (BOM)
• Cut lists
• QA checklists

These are downstream artifacts, not manual work.

Required invariants (non-negotiable)

This pipeline is correct if and only if the following invariants are enforced:

• Ports are always defined as LCS / Datum Coordinate Systems
• Assemblies are built by port mating, not face-based constraints
• Topology ≠ placement ≠ installation
• Schemas are the source of truth
• CAD files are compiled artifacts
• Adjustable components are explicitly declared
• Solving occurs before CAD placement

These invariants guarantee robustness, regeneration, and long-term scalability.

Significance of Parametric Part Libraries and Compiled Assemblies

This approach fundamentally transforms CAD from a manual drafting activity into a declarative, generative engineering process. Instead of drawing geometry directly, designers define intent through reusable part libraries, assembly schemas, and installation constraints, which are then compiled into CAD artifacts.

From Drawings to Systems

Traditional CAD treats each model as a one-off drawing. Geometry is edited directly, assemblies are constrained by faces, and changes propagate unpredictably. This makes reuse difficult, automation fragile, and large systems hard to maintain.

By contrast, a parametric part-library approach treats CAD models as *systems*:

• Parts are defined once, parametrically
• Assemblies are described by topology, not geometry
• Final designs are compiled outputs, not hand-edited artifacts

This shifts CAD from drawing objects to describing how objects relate.

Part Libraries as Stable Building Blocks

Parametric part libraries define:

• Geometry
• Named connection ports (LCS / Datum Coordinate Systems)
• Parameters and allowable variation

These parts become stable, long-lived modules. Once defined, they can be reused indefinitely across assemblies, projects, and buildings without rework. Geometry changes do not break assemblies because connections are semantic, not face-based.

This is the mechanical equivalent of a software standard library.

Assemblies as Declarative Topology

Assemblies are no longer built by dragging parts and adding constraints. Instead, they are described declaratively:

• Which parts are used
• Which ports connect
• Which parameters are set

Assemblies are resolved algorithmically, producing deterministic results. Orientation, placement, and regeneration are handled systematically rather than manually.

This allows assemblies to be:

• Rebuilt from scratch at any time
• Easily modified by changing parameters or part types
• Reused as submodules in larger systems

Final Designs as Compiled Artifacts

Final CAD files are treated as compiled outputs:

• They are generated from schemas
• They are disposable and regenerable
• They are never the source of truth

This eliminates hidden state and manual drift. If requirements change, the schema changes and the design is recompiled.

This mirrors modern software engineering: source code → compiler → executable.

Installation and Context as Separate Concerns

Topology (what connects to what) is separated from installation (where it goes in the world). Site-specific constraints—such as wall penetrations, slopes, and clearances—are applied only at the final compilation stage.

The same assembly design can therefore be installed differently in different buildings without redesign.

Transformation of the CAD Process

This methodology transforms CAD by:

• Replacing manual geometry editing with declarative schemas
• Enabling automation, validation, and regeneration
• Making designs modular, auditable, and scalable
• Allowing human language to be compiled into engineering artifacts
• Treating CAD as a backend, not the primary interface

The result is a shift from artisan drafting to **civilization-scale, system-level design**, where complexity is managed through structure, not manual effort.

Core Insight

Using parametric part libraries and compiled assemblies turns CAD from a tool for drawing into a platform for engineering systems. This enables rapid iteration, large-scale collaboration, automation, and long-term maintainability—capabilities that are impossible with traditional, geometry-centric CAD workflows.

Links

• This describes how to create schemas for wall modules - Wall Module Schema
• But what happens, for example, when you add interior wall modules, and the exterior walls require added blocking? This can be defined in an Assembly Schema. See Integration from Module Schemas to Full Model