Parametric Seastead Design Pipeline — Open Source CAD, Hydro, FEA, Print

Short answers

Yes

A single parametric 3D definition as ground truth is the right idea. OpenSCAD can be that definition for concept work, especially if AI is already writing .scad well for you. All print / hydro / FEA / CFD files should be exports and idealizations of that model, not separately redrawn hulls.

But

Do not send the same STL to the printer, Capytaine, FEA, and OpenFOAM and expect good physics. Each analysis wants a different idealization of the same geometry (watertight outer hull vs printable parts vs shells/beams vs CFD domain). Also: a geometrically scaled plastic print is useful for hydrodynamics (Froude) and for “does it fit,” not as a quantitative stand-in for aluminum strength.

Capytaine is the right first wave tool at this stage, not CFD.
FreeCAD + CalculiX (or Code_Aster) is the most natural open-source FEA path from CSG/STEP.
OpenFOAM is the usual open CFD path later; DualSPHysics is easier for some free-surface look-sees.
If you outgrow OpenSCAD, CadQuery / build123d (Python) plus FreeCAD as a hub is the cleanest open stack that still loves git and AI-generated code.

One ground-truth model

Yes, it is reasonable — it is the whole point of parametric CAD. The mistake is treating “one 3D drawing” as “one mesh.” Think of three layers:

Parameters — lengths, diameters, wall thicknesses, freeboard, draft, material names, print scale, analysis scale.
Master geometry — modules that build the seastead in full-scale meters (or mm, but pick one and never mix).
Views / derivatives — which bodies are included, how they are meshed, and at what scale.

Keep the master in full scale. Scaling for a Froude model is an export option (scale = 1/50), not a second design. That way Capytaine and FEA always see the real vessel, and the printer sees a derived toy.

OpenSCAD is a good master for this phase if your designs are mostly extrusions, hulls of polygons, booleans, and repeating modules (columns, pontoons, decks, trusses). It is weaker when you need class-fair NURBS hulls, production plate expansions, or constraint-based assemblies. You do not need those yet.

How to structure the OpenSCAD project

Split by role, not by “files small enough to print.” A layout that scales:

seastead/
  params.scad              // ALL numbers live here
  lib/
    util.scad              // fillets-as-chamfers, bolts, repeating rings
    materials.scad         // names only; properties for docs/FEA export
  geometry/
    pontoon.scad
    column.scad
    deck.scad
    bracing.scad
    superstructure.scad
  assembly/
    seastead.scad          // full vessel, full scale
    exploded.scad
    printable/             // one file per printer part
      col_lower.scad
      deck_panel_A.scad
  export/
    hydro_hull.scad        // outer wet surface only, closed
    fea_shell.scad         // mid-surfaces or chunky solids
    cfd_body.scad          // outer envelope + maybe appendages
  scripts/
    export.sh              // openscad CLI → stl/amf/3mf
    params.json            // optional mirror of params for Python tools
  README.md                // units, waterline, origin, part map

Rules that keep AI-generated SCAD from rotting

One origin. Put (0,0,0) at a documented point: typically centerline × midships × design waterline, +Z up, +X forward. Write it in the README. Hydro codes assume this kind of frame.
include <params.scad> for numbers. Use use <...> for modules so you do not leak helper geometry into assemblies.
Never duplicate a dimension. If column spacing appears in three parts, it is a parameter, not a literal 12000 in three files.
Two thickness concepts: t_structure (aluminum plate) and t_print (what the FDM nozzle can actually make at the model scale). Do not confuse them.
A PART switch so one file can render “everything” or one printable chunk:

// assembly/seastead.scad
include <../params.scad>
use <../geometry/column.scad>
use <../geometry/pontoon.scad>

part = "assembly"; // override: openscad -D 'part="column"' 

if (part == "assembly") seastead();
if (part == "column")    column();
if (part == "hydro")     hydro_envelope();

OpenSCAD CLI then becomes your “file generator”:

openscad -D 'part="hydro"' -o export/hydro_hull.stl assembly/seastead.scad
openscad -D 'part="column"' -D 'scale=0.02' -o print/column.stl assembly/seastead.scad

Parameters that belong in `params.scad` from day one

Group	Examples
Mission	displacement, payload, persons, draft, freeboard, air gap
Configuration	n_columns, column_spacing, pontoon_L/B/D, deck_size
Structure	plate thicknesses, frame spacing, alloy name
Hydro	waterline Z, density, g, design sea states (Hs, Tp)
Model	lambda (e.g. 50), print_tolerance, split_planes
Mesh	$fn or explicit segment counts for hydro vs print

If you also keep params.json (or YAML) generated from the same numbers, Python tools (Capytaine, Gmsh, CalculiX pre-processors) can read them without parsing SCAD.

How printed parts fit together

Breaking the .scad into printable files is correct. What you are missing is an explicit mating contract, not just “these STLs look like they nest.”

Specify fit in the model, not in a chat log

Named coordinate frames on every part: col_top_flange, deck_socket_A1. Assemble by placing frames on frames, not by magic numbers in the top file.
A part graph. A simple table (CSV or Markdown) listing: part name, parent, transform, fastener, printable yes/no. This is your assembly drawing for humans and for AI.
An explode parameter in assembly/exploded.scad that offsets each part along its insertion axis. Screenshot that for the website and the print-build instructions.
Registration features you would actually print: pins, sockets, lap joints, bolt bosses, keyed tubes. At 1:50, real bolted flanges vanish; replace them with features that survive FDM tolerances (~0.2–0.4 mm).
Interference vs clearance. Parameter fit_clearance (e.g. 0.2 mm on the model) applied only to printable derivatives, never to the full-scale structural model.

OpenSCAD has no real assembly solver (no mates like FreeCAD/Onshape). You simulate that with modules:

module placed_column(i, j) {
  translate([i*s, j*s, 0])
    rotate([0, 0, col_yaw])
      column();
}

If assemblies get painful, keep OpenSCAD as the part generator and do the assembly in FreeCAD (App::Link / Assembly) or even just document transforms in Python. The ground truth for shape can stay SCAD; the ground truth for instance positions can be a small table.

Color / attribute convention

Use color only as metadata in preview: hull = teal, print splits = orange, hydro envelope = translucent blue, omitted internals = gray. It prevents exporting the wrong body to Capytaine.

Deriving the five outputs

#	Job	What to export from the master	Typical open tools
1	Froude-scale print, basin / bathtub / lake waves	Watertight outer geometry, split into printable chunks, scaled by 1/λ, thickened to printable walls, ballast voids	OpenSCAD → STL/3MF → Cura / PrusaSlicer / OrcaSlicer
2	Linear waves, RAOs, added mass, damping	Closed surface of the immersed hull (and maybe internals that trap water). Coarser mesh than print. Full scale, meters.	STL/mesh → meshio / meshmagick / Gmsh → Capytaine
3	Structure strength (concept)	Not the print mesh. Shells (plates) + beams (frames/bracing), or a simplified solid. Full scale.	STEP via FreeCAD, or rebuild plates in FreeCAD FEM / CalculiX / Code_Aster
4	Scaled plastic “structure”	Same as (1) but with deliberate thickness rules; treat as qualitative only	Printer + bathroom-scale loads; do not replace (3)
5	CFD in waves	Outer envelope STL, possibly with a larger domain; ignore cabin furniture	OpenFOAM (interFoam / waves), DualSPHysics, REEF3D

1) Froude-scale printed models

You are already doing this. Make it more scientific:

Scale factor λ = L_full / L_model (you mentioned 50).
Froude similitude: speeds and wave celerities scale as √λ. Periods scale as √λ. Wave heights scale as λ if you want geometric seas (often you cannot in a small tank — document what you actually ran).
Mass / displacement must scale as λ³ (same fluid, water). Design internal ballast volumes so the model floats on the design waterline. FDM infill is not a reliable mass distribution; add lead shot / coins / resin ballast at documented locations (near the intended VCG).
Print the exterior that sees water accurately. Interior decks can be dummy structure for CG and stiffness of the model, not a copy of every bulkhead.

2) Capytaine (do this before CFD)

Capytaine is a Python BEM solver (Nemoh lineage). For concept seasteads it is the highest-leverage wave tool: RAOs, added mass, radiation damping, diffraction forces, mean drift (with care). You can sweep hull proportions in a script, which matches a parametric CAD mindset.

Mesh advice:

Export a closed, manifold, outward-normal hull. No decks above water unless you want windage (Capytaine is hydro).
Panel size: on the order of LWL / 40 to LWL / 80, and several panels per expected wavelength. Print STLs are usually too fine and too ugly (facets, splits, screw bosses).
A separate hydro_hull() module that hull()s or re-skins the wet surface is worth the time.
Repair path: OpenSCAD STL → Gmsh or PyVista / meshio → optionally meshmagick → Capytaine FloatingBody.from_file.
Visualize motions with Capytaine + PyVista or Matplotlib animations of a boxy mesh in Airy waves. That satisfies “see different wave sizes and periods” without CFD.

3) FEA

Early seastead strength questions are almost always: column-to-pontoon joints, deck truss under self-weight + payload, splitting forces in waves (squeezing/prying of multi-hulls), and punching from slamming. A tetrahedral soup of the 3D-print STL will not answer those well.

Better idealizations, in order of usefulness at concept stage:

Beam model (columns, braces) + plate/shell decks and pontoon sides.
Coarse shell model of the aluminum skin with simple rigid or beam frames.
Local solid models of one joint, loads taken from (1) or from Capytaine.

Load path: hydrostatics + inertia from RAOs (inertia relief or quasi-static “frozen” wave) is enough before the NA. You are looking for order-of-magnitude stress and whether a 12 mm plate is fantasy.

5) CFD

Park it until Capytaine plus a printed model have ranked the hulls. Nonlinear waves, viscous drag, vortex shedding off columns, moonpools, and slamming are CFD problems; linear seakeeping of a large displacement seastead is not. CFD in waves is expensive and easy to mis-set (damping, beach, mesh at the free surface).

Plastic 1:50 vs full-scale aluminum

Short version: a 1:50 FDM model can teach you hydrodynamics and arrangement. It cannot certify that aluminum is strong enough. It can, with eyes open, give a rough stiffness vibe, and it will mislead you on failure.

Two different scalings

What you want to match	Law	Implication at λ = 50, model in water
Waves, inertia, gravity (float, RAOs, green water qualitatively)	Froude	Correct for basin tests if mass, CG, and gyration radii are scaled. This is output (1).
Elastic deformation under those hydro loads (hydroelasticity)	Froude + Cauchy (E scaled)	Need E_model / E_full ≈ (ρ_m/ρ_f) / λ. In water, ≈ 1/50.
Yield / fracture / buckling collapse	Strength + geometric + residual stress similitude	FDM plastic does not match. Stop.

The modulus coincidence (why people get tempted)

Aluminum E ≈ 70 GPa. PLA/PETG ≈ 2–3 GPa. Ratio ≈ 1/23 to 1/35. Cauchy+Froude wanted ≈ 1/50. So a geometrically scaled solid plastic model is in the same decade of stiffness as aluminum in waves — closer than intuition suggests — but:

It is still ~1.5–2× too stiff (or the wrong factor if you used infill).
Yield strength ratio is much worse. PLA yield ~40–60 MPa vs 6061-T6 ~270 MPa (ratio ~1/5, not 1/50). The plastic model is relatively too strong. It will not break when the aluminum would, and it may creep instead.
FDM is orthotropic. Layer bonds are not aluminum welds. A print that survives is almost meaningless for a welded joint.
Self-weight stresses scale differently from wave stresses. A dry plastic model under 1 g is not a Froude-scaled structure.
Buckling of thin aluminum plate (real seasteads are skins + stiffeners) does not happen in a 1:50 print unless you print foil-thin walls, which then wrinkle from printing, not physics.

Rules that make plastic still helpful

Use prints for Froude hydro and for human factors / assembly. That is already high value.
Do not scale structure and hydro with the same part if you care about stress. Hydro model: correct exterior and mass. Structural coupon: larger scale (1:5–1:10) joints, or FEA.
If you want a stiffness look-see, print solid or high-infill, geometric thickness, and treat deflections as ± factor of two. Compare which concept is stiffer, not “peak stress is 82 MPa.”
Match dimensionless stiffness if you go further: (E I) / (ρ g L⁵) for beams, or (E t³) / (ρ g L⁴) for plates. You may have to distort thickness (thicker or thinner than geometric scale) to put plastic in the right ballpark. Distorted models need a written rule or they are toys.
Never use infill percentage as a stand-in for plate slenderness.
Joints: print them at a scale where bolts are real bolts, or drop the idea and FEA the joint.

Practical recommendation

Drop output (4) as a strength argument. Keep prints for waves and fit. Put “is aluminum thick enough?” on FEA with loads from Capytaine, then let the naval architect clean it up. If you want a physical structural sanity check, print or machine a single joint at 1:5, not a whole seastead at 1:50.

Open-source FEA and CFD that work with what OpenSCAD generates

OpenSCAD’s native children are STL/OFF/AMF and CSG. STL is a surface skin. FEA and good CFD want more.

Geometry bridges

FreeCAD — import SCAD or STL; rebuild or convert toward STEP; FEM workbench.
Gmsh — mesh from STL or STEP; control sizes; export for CalculiX / Code_Aster / OpenFOAM.
meshio — Python Swiss army knife between mesh formats.
OpenSCAD → CGAL CSG is not a substitute for a CAE solid. Plan on a rebuild of analysis geometry.

FEA (open)

FreeCAD FEM + CalculiX — best “one GUI” path.
CalculiX — industrial, shells and solids, input decks you can generate.
Code_Aster + Salome-Meca — more powerful, steeper.
Elmer, FEniCS — if you like writing PDEs; overkill here.
Mystran, OpenRadioss — niche; later.

Hydro / waves (open)

Capytaine — linear BEM, first choice.
HAMS, NEMOH — other BEM options.
meshmagick — hydrostatics, mesh repair.
DAVE — scene / hydro visualization in Python.
Hydrostatics you can also script: displaced volume, BM, GM from the same mesh.

CFD (open)

OpenFOAM + interFoam / wave generation (olaFlow, waves2Foam, or newer wave modules).
DualSPHysics — SPH, friendlier for violent free surface, weaker for long seakeeping runs.
REEF3D — coastal/ocean CFD, good wave physics.
Basilisk — beautiful adaptive two-phase; more research-y.

STL from OpenSCAD → snappyHexMesh (OpenFOAM) is a standard path for an outer hull. It is not a good path for FEA plates.

Recommended software stacks

All open source. Ranked for your constraints: AI-written code, OpenSCAD comfort, concept stage, no NA yet.

Stack A — Stay on OpenSCAD (lowest friction)

params.scad + modules
    ├─ CLI STLs → slicer → print (Froude)
    ├─ hydro_hull.stl → mesh repair → Capytaine → RAOs / animation
    ├─ rebuild shells in FreeCAD FEM → CalculiX
    └─ (later) hull.stl → OpenFOAM snappyHexMesh

Best if designs stay CSG-simple. AI keeps editing .scad. You accept that FEA geometry is a simplified cousin, still driven by the same parameters.

Stack B — Python CAD as master (best if you are willing to switch)

params.yaml
  CadQuery 2  or  build123d   →  STEP + STL
    ├─ print STLs
    ├─ Capytaine
    ├─ Gmsh → CalculiX
    └─ OpenFOAM

Why it is better long-term: real solids and STEP, fillets that are not lies, the same language as Capytaine (Python), tests, git diffs that are readable, AI is at least as good at Python as at SCAD. SolidPython is a halfway house (Python that emits OpenSCAD) if you want a gentle move.

Stack C — FreeCAD as hub

Spreadsheet workbench for parameters, Part or PartDesign (or import SCAD), FEM, Mesh, TechDraw for assembly sheets. Steeper interactive GUI, weaker for “AI writes the whole vessel,” stronger for STEP and FEA. Good as the downstream hub even if SCAD remains upstream.

Is there a better set that does all four off one base model?

There is no open-source “seastead suite” that honestly does print + BEM + FEA + CFD from one button. Commercial naval tools (Rhino + Orca3D, Maxsurf, NAPA, ANSYS Aqwa, WAMIT, Star-CCM+) still do not really do FDM split parts for you.

The winning pattern in open source is:

parametric solid (SCAD or CadQuery) → many exporters → specialist solvers

with a strict rule that parameters never fork. If you want one GUI over that, FreeCAD is the closest. If you want one language over that, Python (CadQuery + Capytaine + PyVista + meshio + subprocess to CalculiX/OpenFOAM) is the closest.

Blender is tempting for wave visuals and even geometry nodes, but it is a poor structural source of truth. Use it for pictures, not for plate thickness.

What is good enough before a naval architect

You said you will hire an NA before anything full scale. Use that. Your job is to kill bad configurations cheaply and walk in with a concept that already has:

A parametric geometry and a one-page design basis (displacement, payload, draft, environment).
Hydrostatics: displacement, KB, BM, GM, floodable length at a cartoon level.
Capytaine RAOs in a few headings for 2–3 sea states; motions at the deck and at a column top.
A printed Froude model that sits on the waterline you think it does, and does not face-plant in small waves.
A back-of-envelope or coarse FEA on the “obviously scary” joint, with environmental loads from the BEM, showing stresses that are not 10× material allowable.
A list of things you know you ignored: fatigue, slamming spectra, redundancy after a flooded pontoon, connection details, marine welding, mooring, station-keeping, ice, corrosion, regulation.

That is a strong NA handoff. It is not class approval, and it should not try to be.

Other tools worth knowing

OpenFAST / FAST.Farm / MoorDyn / RAFT — if the seastead starts looking like a floating offshore platform with moorings. Born for wind, usable for floaters.
MoorPy, MoorDyn — catenary / mooring sketches.
PyWake / nothing — skip unless you have turbines.
Hydrostatics in a notebook — integrating the OpenSCAD mesh with trimesh or meshmagick is often enough for GM.
Slicers with pause-at-height — for embedding ballast and waterproofing strategies (epoxy coat, PETG vs PLA; PLA is hygroscopic and creeps — PETG/ASA better in water).
Git — .scad and Python belong in git; binary STLs do not, except tagged releases.
Wave tanks without a tank — a long lake towing a homemade plunger, or even a documented “boat wake protocol,” beats no hydro test. Measure with a phone IMU on the model.
Literature to steal configurations from: VLFS, semi-subs, SPAR, Very Large Floating Structures, MOB, Box-type pontoons, column-stabilized platforms. Your CAD should be able to swap those topologies via parameters, not via a new repo.

A practical next-step recipe

Freeze a coordinate system, units (meters), and params.scad.
Refactor existing AI SCAD into modules + assembly + hydro_envelope + printable parts as above. Add explode and a part table.
Write scripts/export.sh so a clean checkout can regenerate every STL.
Build hydrostatics + Capytaine in a Python notebook that reads the hydro STL and params.json. Sweep two variables (column spacing, draft) before you sculpt superstructure.
Print one λ = 50 (or larger if the printer allows — bigger is better for Froude in messy small waves) hull, ballast to WL, put an IMU on it.
In FreeCAD FEM, make a beam/shell cartoon of the same parameters; apply a few static load cases (still water, one sagging wave, one splitting load). Decide if aluminum plate is even in the conversation.
Only then consider OpenFOAM for a problem Capytaine cannot touch (a moonpool, a breaking-wave slam, viscous yaw damping).
Walk into the NA with the param list, RAO plots, a video of the model, and the FEA cartoon — plus the list of ignored physics.

Bottom line

One parametric source of truth: yes. OpenSCAD as that source: yes for this phase. One mesh for every physics: no. Plastic 1:50 as aluminum: no, except qualitative stiffness and hydro. Best open companions: Capytaine, FreeCAD/CalculiX, Gmsh, OpenFOAM later. Best upgrade path if SCAD gets cramped: CadQuery/build123d with the same parameter file.