FreeCAD Plumbing Designer - Revision history

Marcin: /* Links */

2026-01-27T05:53:59Z

Links

← Older revision		Revision as of 05:53, 27 January 2026
Line 260:		Line 260:
	=Links=		=Links=
	*This describes how to create schemas for wall modules - [[Wall Module Schema]]		*This describes how to create schemas for wall modules - [[Wall Module Schema]]
	*See ~~also~~ [[Integration from Module Schemas to Full Model]]		*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]]

Marcin: /* Links */

2026-01-27T05:53:04Z

Links

← Older revision		Revision as of 05:53, 27 January 2026
Line 260:		Line 260:
	=Links=		=Links=
	*This describes how to create schemas for wall modules - [[Wall Module Schema]]		*This describes how to create schemas for wall modules - [[Wall Module Schema]]
			*See also [[Integration from Module Schemas to Full Model]]

Marcin: /* Core Insight */

2026-01-27T05:45:08Z

Core Insight

← Older revision		Revision as of 05:45, 27 January 2026
Line 257:		Line 257:

	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.		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]]

Marcin: /* Required invariants (non-negotiable) */

2026-01-27T05:39:34Z

Required invariants (non-negotiable)

← Older revision		Revision as of 05:39, 27 January 2026
Line 185:		Line 185:

	These invariants guarantee robustness, regeneration, and long-term scalability.		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.

Marcin: /* Big Deal */

2026-01-27T05:36:59Z

Big Deal

← Older revision		Revision as of 05:36, 27 January 2026
Line 1:		Line 1:
	=Big Deal=		=Big Deal=
	Study this thread, which describes the steps for generating modules, assemblies, and final modifications - fully automated by schemas and compilers. One just runs compilers to regenerate new iterations of design. ~~Based~~ on plumbing, which has an extra layer of complexity over structure in terms of more complicated mating surfaces and part orientations.		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		https://chatgpt.com/share/69784c9d-969c-8010-8eea-339e43a4811d

Marcin at 05:35, 27 January 2026

2026-01-27T05:35:54Z

← Older revision		Revision as of 05:35, 27 January 2026
Line 26:		Line 26:

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

	~~= 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.~~

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

Marcin at 05:35, 27 January 2026

2026-01-27T05:35:36Z

← Older revision		Revision as of 05:35, 27 January 2026
Line 27:		Line 27:
	The system treats plumbing as a compiled artifact, not a hand-edited drawing. This procedure applies to all modules/systems, not just plumbing.		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) =		= 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.

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

	Each plumbing part is defined by a long-lived, design-time schema.		Each plumbing part is defined by a long-lived, design-time schema.
Line 40:		Line 46:
	The schema is the source of truth. Geometry is not edited directly.		The schema is the source of truth. Geometry is not edited directly.

	= 2. Compile schemas → generate CAD parts =		== 2. Compile schemas → generate CAD parts ==

	Part schemas are compiled into CAD artifacts (e.g. <code>.FCStd</code>).		Part schemas are compiled into CAD artifacts (e.g. <code>.FCStd</code>).
Line 51:		Line 57:
	CAD file = compiled artifact		CAD file = compiled artifact

	= 3. CAD library provided to Chat =		== 3. CAD library provided to Chat ==

	Canonical part definitions are provided to Chat via:		Canonical part definitions are provided to Chat via:
Line 57:		Line 63:
	* Or a subset of parts plus the formal part interface contract		* Or a subset of parts plus the formal part interface contract

	Chat uses ~~this~~ to:		Chat uses these to:
	* Learn port names and conventions		* Learn port names and conventions
	* Validate compatibility		* Validate compatibility
Line 64:		Line 70:
	The full library does not need to be re-uploaded once conventions are fixed.		The full library does not need to be re-uploaded once conventions are fixed.

	= 4. Assembly topology schema generated from human language =		== 4. Assembly topology schema generated from human language ==

	Human-language instructions such as:		Human-language instructions such as:
Line 82:		Line 88:
	There is no site placement or house context at this stage.		There is no site placement or house context at this stage.

	= 5. Compile topology schema → local assembly =		== 5. Compile topology schema → local assembly ==

	The topology schema is compiled into a local plumbing assembly:		The topology schema is compiled into a local plumbing assembly:
Line 94:		Line 100:
	* Independent of any specific building		* Independent of any specific building

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

	To place the plumbing in a building, installation constraints are provided, including:		To place the plumbing in a building, installation constraints are provided, including:
Line 106:		Line 112:
	Human language is acceptable; it is compiled into a formal constraint schema.		Human language is acceptable; it is compiled into a formal constraint schema.

	= 7. Upload full house CAD file =		== 7. Upload full house CAD file ==

	The house CAD model provides:		The house CAD model provides:
Line 117:		Line 123:
	'''Plumbing is not edited into the house; it is placed into the house.'''		'''Plumbing is not edited into the house; it is placed into the house.'''

	= 8. Generate solved assembly schema for final insertion =		== 8. Generate solved assembly schema for final insertion ==

	Using:		Using:
Line 133:		Line 139:
	At this stage, the system is fully determined and unambiguous.		At this stage, the system is fully determined and unambiguous.

	= 9. Run compiler locally =		== 9. Run compiler locally ==

	The compiler is executed locally with:		The compiler is executed locally with:
Line 147:		Line 153:
	This is the correct trust boundary.		This is the correct trust boundary.

	= 10. Generate final CAD assembly =		== 10. Generate final CAD assembly ==

	The output is a final CAD file that:		The output is a final CAD file that:
Line 157:		Line 163:
	The plumbing is correctly placed within the house model.		The plumbing is correctly placed within the house model.

	= 11. Generate downstream artifacts automatically =		== 11. Generate downstream artifacts automatically ==

	Because:		Because:
Line 172:		Line 178:
	These are downstream artifacts, not manual work.		These are downstream artifacts, not manual work.

	= Required invariants (non-negotiable) =		== Required invariants (non-negotiable) ==

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

Marcin: /* Declarative Plumbing CAD Pipeline (Schema → Assembly → Installation) */

2026-01-27T05:34:20Z

Declarative Plumbing CAD Pipeline (Schema → Assembly → Installation)

← Older revision		Revision as of 05:34, 27 January 2026
Line 25:		Line 25:
	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).		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.		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) =		= 1. Generate schemas for all plumbing library parts (parametric) =

Marcin: /* Execution */

2026-01-27T05:33:23Z

Execution

← Older revision		Revision as of 05:33, 27 January 2026
Line 21:		Line 21:
	*From here I can get technical drawings and BOM automatically.		*From here I can get technical drawings and BOM automatically.

	~~=Execution=~~
	= Declarative Plumbing CAD Pipeline (Schema → Assembly → Installation) =		= Declarative Plumbing CAD Pipeline (Schema → Assembly → Installation) =

Marcin: /* Concept 1 */

2026-01-27T05:33:09Z

Concept 1

Show changes