Parametric CAD and simulation workflow for seastead concept studies

Short answer and recommended approach

Key recommendations:

1. Keep OpenSCAD if it is working well for concept generation and 3D printing. It is especially good for early parametric geometry, AI-assisted iteration, and STL/3MF production.
2. Treat OpenSCAD output as mesh output, not as a complete engineering model. STL/3MF meshes are fine for printing and can sometimes be used for CFD or hydrodynamic meshing, but they are usually not ideal for serious FEA unless cleaned, simplified, and converted into shell/beam models.
3. For engineering-grade workflows, consider making FreeCAD or CadQuery/build123d the master CAD system instead of OpenSCAD. These can produce STEP/BREP boundary representation geometry, which is much better for FEA and CFD meshing.
4. Use Capytaine for early wave response and RAO-type studies. It is much faster than CFD and appropriate for first-pass wave performance screening.
5. Use Gmsh as a mesh hub for FEA and CFD. Gmsh can import STEP/BREP and, with care, STL/OBJ surfaces.
6. Use CalculiX, Elmer, or Code_Aster for FEA. Use OpenFOAM, optionally with olaFlow/waves2Foam/REEF3D-type wave tools, for CFD.
7. A 1:50 plastic structural model can be useful, but only if you understand scaling laws. It can give qualitative insight into stiffness, load paths, buckling shapes, and weak zones. It should not be used as a direct quantitative prediction of full-scale aluminum strength unless you carefully match similitude parameters.

Should OpenSCAD be the single ground truth?

Yes, at the concept stage it is reasonable to use a single parametric source of truth. The important point is that the “ground truth” should include more than one geometry file. It should include:

• Design parameters: length, beam, draft, freeboard, pontoon radius, deck height, plate thickness assumptions, etc.
• Global coordinate system: one origin, one orientation, one unit convention.
• Part definitions: separate modules for hulls, pontoons, decks, columns, bulkheads, etc.
• Assembly definition: explicit translations/rotations placing each part into the global frame.
• Print split rules: cutting planes, print envelopes, alignment features, tolerances.
• Export rules: scripts or Makefiles producing STL/3MF for printing, meshes for Capytaine/CFD, and STEP/BREP if using FreeCAD/CadQuery.
• Validation scripts: watertightness checks, volume checks, mass properties, mesh quality checks.

So my advice is:

For your current stage, I would probably do this:

1. Keep OpenSCAD for early concept generation and Froude scale printing.
2. Once a concept looks promising, convert or recreate it in FreeCAD or CadQuery/build123d.
3. Use that engineering CAD model to export STEP/BREP for Gmsh, FEA, and CFD.
4. Use OpenSCAD/CAD STL output for physical printing.

Suggested repository structure

A good structure separates design parameters, part modules, assembly, printing splits, export scripts, and simulation inputs. This keeps the model maintainable and makes it easier for AI tools to edit only the correct layer.

seastead-project/
├── README.md
├── Makefile                  # or justfile / build script
├── params/
│   ├── design_v001.yaml      # human-readable design parameters
│   ├── design_v002.yaml
│   └── materials.yaml
├── cad/
│   ├── common/
│   │   ├── units.scad
│   │   ├── parameters.scad
│   │   ├── coordinate_system.scad
│   │   ├── connectors.scad
│   │   └── print_helpers.scad
│   ├── parts/
│   │   ├── pontoon.scad
│   │   ├── deck_box.scad
│   │   ├── column.scad
│   │   ├── bulkhead.scad
│   │   └── mooring_bracket.scad
│   ├── assembly/
│   │   ├── full_seastead.scad
│   │   └── wetted_hull.scad
│   ├── print/
│   │   ├── part_01_bow.scad
│   │   ├── part_02_midship.scad
│   │   └── part_03_stern.scad
│   └── variants/
│       ├── catamaran_a.scad
│       ├── semisub_b.scad
│       └── spar_c.scad
├── scripts/
│   ├── export_stl.sh
│   ├── export_3mf.sh
│   ├── check_mesh.py
│   ├── stl_to_hydro_mesh.py
│   ├── capytaine_run.py
│   ├── gmsh_mesh.py
│   └── openfoam_setup.sh
├── build/
│   ├── print/
│   ├── hydro/
│   ├── fea/
│   └── cfd/
├── sim/
│   ├── capytaine/
│   ├── fea/
│   └── cfd/
└── docs/
    ├── scaling_laws.md
    ├── assumptions.md
    └── naval_architect_handoff.md

The important idea is that every exported file should be traceable to a specific design version and git commit. A naming convention helps a lot:

designA_v003_full_hydro.obj
designA_v003_s50_print_part01.stl
designA_v003_full_structural.step
designA_v003_full_fea.msh
designA_v003_full_cfd.stl

How to organize multiple OpenSCAD files and fit them together

OpenSCAD does not have a full constraint-based assembly system like a traditional CAD package. However, you can create a robust assembly pattern using modules, explicit transforms, shared parameters, and named connection features.

1. Use include for shared parameters and use for modules

In OpenSCAD:

• include <file.scad> brings in variables, functions, and modules. Use it for shared parameters.
• use <file.scad> brings in modules but not variables. Use it for part modules.

// common/parameters.scad
unit_mm = 1;

// Full-scale design parameters, stored in mm for OpenSCAD convenience.
full_length = 24000;
full_beam = 12000;
design_draft = 3500;
freeboard = 2000;
pontoon_radius = 1500;

// Waterline is z = 0. Hull below waterline has negative z.
waterline_z = 0;

// Printing
printer_clearance = 0.25;
wall_thickness_print = 2.0;

// assembly/full_seastead.scad
include <../common/parameters.scad>
use <../parts/pontoon.scad>
use <../parts/deck_box.scad>

module seastead() {
  pontoon(x_offset = -full_length/4, y_offset = -full_beam/4);
  pontoon(x_offset = -full_length/4, y_offset =  full_beam/4);
  pontoon(x_offset =  full_length/4, y_offset = -full_beam/4);
  pontoon(x_offset =  full_length/4, y_offset =  full_beam/4);

  deck_box(
    length = full_length * 0.9,
    width = full_beam * 0.9,
    z_top = freeboard
  );
}

seastead();

2. Define local origins for every part

Each part should have a predictable local origin. For example:

• Pontoon: origin at mid-length, centerline, baseline or keel.
• Deck box: origin at center of deck footprint, underside of deck.
• Column: origin at bottom center.
• Bulkhead: origin at center of its reference plane.

This makes assembly transforms easier to reason about and reduces hidden alignment errors.

3. Use explicit assembly transforms

Avoid relying on visual alignment. Put every transform in code.

module assembled_seastead() {
  translate([0, 0, 0])
    base_hull();

  translate([0, 0, deck_z])
    deck_structure();

  translate([mooring_x, mooring_y, mooring_z])
    rotate([0, 0, mooring_angle])
      mooring_bracket();
}

4. Create connector features

For 3D-printed split models, define male/female connectors, dowel holes, flanges, lap joints, or snap features. Put these in a shared library so every part uses the same tolerances.

// common/connectors.scad
module dowel_hole(d = 10, h = 20, clearance = 0.25) {
  cylinder(d = d + 2*clearance, h = h, $fn = 48);
}

module dowel_pin(d = 10, h = 20, clearance = 0.25) {
  cylinder(d = d - clearance, h = h, $fn = 48);
}

module flange_joint(thickness = 4, bolt_spacing = 30) {
  // Define a reusable mating flange here.
}

5. Use print envelopes or cutting planes to split the model

// print/part_01_bow.scad
include <../common/parameters.scad>
use <../assembly/full_seastead.scad>

module print_envelope() {
  cube([250, 180, 180], center = true);
}

intersection() {
  seastead();

  translate([full_length/4, 0, 0])
    print_envelope();
}

6. Consider a machine-readable assembly manifest

If you have many variants, you can keep the assembly layout in YAML or JSON and generate OpenSCAD code from Python. Example YAML:

assembly:
  - part: pontoon
    file: parts/pontoon.scad
    translate: [-6000, -3000, -1500]
    rotate: [0, 0, 0]

  - part: pontoon
    file: parts/pontoon.scad
    translate: [-6000, 3000, -1500]
    rotate: [0, 0, 0]

  - part: deck_box
    file: parts/deck_box.scad
    translate: [0, 0, 2000]
    rotate: [0, 0, 0]

A Python script can turn this into an OpenSCAD assembly file. This is useful if AI is helping you generate many variants.

Deriving the different output files

1. 3D-printed Froude scale model

For a Froude scale physical model, the scale factor is usually defined as:

lambda = L_full / L_model

For a 1:50 model, lambda = 50.

Froude scaling rules:

For a physical seakeeping model, you generally need to scale:

• Hull geometry.
• Displacement mass.
• Center of gravity.
• Radius of gyration / mass moments of inertia.
• Wave height and wave period.
• Mooring stiffness, if moorings are included, using a carefully scaled equivalent system.

2. Capytaine wave simulations

Capytaine is a good open-source tool for early wave response analysis. It is a boundary-element-method potential-flow tool, not a full CFD tool. That makes it much faster for exploring many wave periods, directions, and geometries.

Capytaine is appropriate for:

• Linear wave excitation forces.
• Radiation damping.
• Added mass.
• Response amplitude operators, RAOs.
• First-pass seakeeping in regular and irregular waves.
• Comparing alternative hull forms.

Capytaine is less appropriate for:

• Breaking waves.
• Strong viscous drag.
• Slamming and green water.
• Large-amplitude nonlinear motions.
• Flow separation-dominated behavior.
• Detailed structural loads near connections.

OpenSCAD STL output can be used as a starting point, but you will usually want to process it before using it in Capytaine:

1. Export the hull at the desired scale, preferably full scale in meters for solver clarity.
2. Cut the hull at the design waterline, keeping the wetted surface.
3. Make sure the mesh is watertight and manifold.
4. Remove duplicate vertices and sliver triangles.
5. Decimate or remesh to reasonable panel sizes.
6. Check normals: they should point outward from the body.
7. Follow Capytaine guidance regarding waterplane closure or lids if needed for your mesh type.

A Python conversion script is useful here. The exact API may vary, but conceptually it may look like:

# Pseudo-code, not necessarily exact current Capytaine API.
import capytaine as cpt

vertices, faces = load_clean_panel_mesh("build/hydro/hull_wetted.obj")

body = cpt.FloatingBody(
    mesh=cpt.Mesh(vertices=vertices, faces=faces)
)

body.add_all_rigid_body_dofs()

solver = cpt.BEMSolver()

# Loop over wave periods, directions, and frequencies.
# Compute RAOs, excitation forces, radiation damping, etc.

For visualization of different wave sizes and periods, you can:

• Plot RAOs with Python/matplotlib.
• Export free-surface elevation or pressure data for ParaView if supported by your workflow.
• Generate regular-wave cases first, then irregular-wave spectra such as JONSWAP or Pierson-Moskowitz.

3. Finite element analysis, FEA

For structural FEA, an STL from OpenSCAD is usually not the best direct input. Marine structures are normally modeled as shells, plates, beams, stiffeners, bulkheads, and frames. A dense solid STL of the whole seastead can become enormous and may not represent the actual structural behavior well.

Better workflow:

1. Create or convert the structural geometry into STEP/BREP.
2. Create mid-surfaces for plates and shells.
3. Create beam/line elements for stiffeners, frames, and major members.
4. Mesh with Gmsh, Netgen, Salome, or FreeCAD FEM tools.
5. Solve with CalculiX, Elmer, or Code_Aster.
6. Apply loads from hydrostatic pressure, wave pressure, weight, ballast, equipment, wind, and mooring points.

If you stay purely with OpenSCAD, one possible but weaker route is:

OpenSCAD STL -> mesh cleanup -> volume mesh -> FEA

This can work for rough solid-model studies, but it is usually not ideal for marine plate/shell structures. For a seastead, shell and beam modeling is normally much more useful.

4. Plastic scaled structural model

See the dedicated section below. A plastic model can be helpful, but only with careful scaling rules.

5. CFD

OpenFOAM is the main open-source CFD option worth considering. OpenSCAD STL files can be used with OpenFOAM’s snappyHexMesh, but mesh quality and geometry cleanliness are critical.

For wave CFD, useful open-source options include:

• OpenFOAM with interFoam or similar multiphase solvers.
• olaFlow for wave generation, absorption, and porous media.
• waves2Foam for wave boundary conditions, depending on OpenFOAM version and setup.
• REEF3D for coastal/wave-focused simulations.
• Basilisk for adaptive multiphase flow.
• DualSPHysics for SPH simulations of violent free-surface flows.

Can a 1:50 plastic model say anything about full-scale aluminum strength?

Why direct strength scaling is difficult

If you scale geometry by a factor lambda = 50, many structural quantities do not scale in the same way. For Froude-scaled wave loads:

This means that a geometrically scaled model under Froude-scaled loads may appear stronger or stiffer than it should relative to the full-scale structure.

Useful dimensionless groups

To make a scaled structural model meaningful, you should think in terms of dimensionless similarity parameters.

For stiffness similarity with Froude scaling, you would ideally like:

E_model / E_full = L_model / L_full = 1 / lambda

For a 1:50 model of aluminum:

E_aluminum ≈ 70 GPa
Target E_model ≈ 70 GPa / 50 ≈ 1.4 GPa

Many 3D-printed plastics have effective moduli in the rough range of 1 to 3 GPa, depending on material, infill, orientation, and print quality. So for stiffness, a plastic model can sometimes be in the right ballpark.

For strength similarity, you would like:

sigma_y_model / sigma_y_full = 1 / lambda

For aluminum with yield strength around 250 MPa:

Target sigma_y_model ≈ 250 MPa / 50 ≈ 5 MPa

Most solid 3D-printed plastics are much stronger than 5 MPa, even accounting for layer adhesion. Therefore, a normal plastic model is often too strong relative to the scaled loads. It may not fail when the full-scale aluminum structure would be approaching its limit.

Practical rules for making a plastic structural model useful

1. Use it for qualitative behavior, not final strength. It can show load paths, flexible zones, buckling modes, torsional weakness, and poor connection details.
2. Define the scaling law explicitly. Write down the length scale, load scale, pressure scale, stiffness target, and strength target.
3. Measure printed material properties. Print test coupons and measure effective tensile modulus and strength in the relevant directions. Printed parts are anisotropic.
4. Tune effective stiffness with infill. If solid PLA or PETG is too stiff, reduce infill, use a different pattern, or use a more flexible material.
5. Beware minimum wall thickness. If full-scale plate thickness is 10 mm, a 1:50 geometric thickness is 0.2 mm. That is usually impractical for FDM printing and may not represent real plate behavior.
6. Apply scaled loads carefully. Use pressure scaling, point-load scaling, or ballast scaling rather than just “push on it by hand.”
7. Measure deflections and strains. Use dial indicators, strain gauges, or simple displacement markers. Compare against FEA, not just intuition.
8. Do not use it for fatigue, corrosion, connection design, or code compliance. Those require proper engineering analysis.

Open-source software options

What works well with OpenSCAD output?

A better software stack if you want one base model for many outputs

There is no single open-source program that perfectly does CAD, slicing, Capytaine hydrodynamics, FEA, and CFD in one environment. The practical answer is a scripted pipeline with a single parametric geometry source and interchangeable open formats.

A good open-source pipeline would look like this:

Design parameters
   |
   v
Parametric CAD
OpenSCAD / CadQuery / FreeCAD
   |
   +--> STL/3MF for 3D printing
   |
   +--> Clean watertight mesh for Capytaine
   |
   +--> STEP/BREP for structural FEA
   |        |
   |        +--> Gmsh shell/volume mesh
   |        +--> CalculiX / Elmer / Code_Aster
   |
   +--> STL/STEP for CFD
            |
            +--> OpenFOAM snappyHexMesh
            +--> interFoam / olaFlow / waves2Foam / REEF3D

Recommended stack for your stage

1. Concept geometry: OpenSCAD if you are already productive with it.
2. Engineering geometry: FreeCAD or CadQuery/build123d once a concept becomes promising.
3. Mesh hub: Gmsh, plus Python tools such as trimesh and PyVista.
4. Wave response: Capytaine.
5. Structural FEA: CalculiX via FreeCAD FEM or directly via Gmsh-generated meshes. Elmer or Code_Aster if needed.
6. CFD: OpenFOAM with wave extensions, used selectively.
7. Visualization: ParaView and Python/matplotlib.

If you want to stay mostly in OpenSCAD

You can still build a useful pipeline. The key is to add scripts that convert and validate OpenSCAD exports.

openscad -D 'DESIGN="catamaran_a"' \
         -D 'SCALE=1/50' \
         -D 'PART="part_01_bow"' \
         -o build/print/catamaran_a_s50_part_01_bow.stl \
         cad/print/export_part.scad

You can also use OpenSCAD’s command-line variable overrides to generate many variants from one master file. A Makefile or Python script can regenerate all STL files, hydro meshes, and simulation inputs whenever the CAD source changes.

If you want a more engineering-grade future path

I would seriously consider CadQuery/build123d or FreeCAD as the master geometry system. The reason is simple: STEP/BREP geometry is much easier to use for FEA and CFD than STL meshes.

CadQuery/build123d may be especially good if you are already using AI to generate OpenSCAD, because AI can also generate Python CadQuery code. The output is often more suitable for downstream engineering tools.

Recommended practical plan

Phase 1: Fast concept screening with OpenSCAD

1. Create several parametric OpenSCAD variants.
2. Export STL/3MF files for small Froude scale printing.
3. Check buoyancy, volume, deck layout, and basic visual plausibility.
4. Use simple hydrostatic checks from watertight meshes: displacement, center of buoyancy, waterplane area.
5. Document assumptions and scale factors.

Phase 2: Hydrodynamic screening with Capytaine

1. Select the best 3 to 5 concepts.
2. Generate clean wetted-surface meshes below the design waterline.
3. Run Capytaine over a range of wave periods and directions.
4. Compare RAOs, wave excitation forces, and motion responses.
5. Identify concepts with poor motion behavior or resonance problems.

Phase 3: Preliminary structural sanity check

1. Move promising concepts into FreeCAD or CadQuery.
2. Create simplified structural surfaces: hull plates, deck plates, bulkheads, columns, pontoons.
3. Export STEP/BREP.
4. Mesh with Gmsh.
5. Run simple CalculiX or Elmer load cases: static pressure, weight, patch loads, simplified wave bending.
6. Do not attempt final code compliance yet; just remove obviously weak concepts.

Phase 4: Selective CFD

1. Use OpenFOAM or another wave CFD tool only for cases where potential flow is not enough.
2. Examples: wave overtopping, slamming, moonpools, viscous damping, strong flow separation, breaking waves.
3. Keep the geometry simplified. Remove tiny features that do not affect global wave behavior.

Phase 5: Physical model validation

1. Print a Froude scale model of the selected concept.
2. Ballast it to the correct displacement, center of gravity, and mass moments of inertia.
3. Test in regular waves first, then irregular waves if possible.
4. Compare observed motions and loads with Capytaine predictions.
5. Use discrepancies to improve assumptions before paying for detailed naval architecture.

Checklist before going to a naval architect

You do not need full naval-architecture-level detail yet, but the following package will make the naval architect much more effective:

Bottom line

Yes, use one parametric ground-truth model. But make it a disciplined parametric model repository, not just one scattered OpenSCAD file. For your current stage, OpenSCAD is a reasonable master for concept generation and 3D printing. For better FEA and CFD compatibility, plan to move promising designs into FreeCAD or CadQuery/build123d so that you can export STEP/BREP geometry.

A practical open-source toolchain would be:

OpenSCAD / CadQuery / FreeCAD
+ Gmsh
+ Capytaine
+ CalculiX or Elmer or Code_Aster
+ OpenFOAM / olaFlow / waves2Foam / REEF3D
+ ParaView

Use Capytaine for early wave behavior, FEA for structural sanity, CFD selectively for nonlinear/viscous questions, and plastic scale models for qualitative insight and physical validation. With this approach, you can explore many designs cheaply and bring a much more useful package to the naval architect.