One Parametric Design, Several Purpose-Built Models

1. What Each Application Actually Needs

A printer needs a closed solid. A thin-walled structural model often needs a surface with an assigned thickness. A hydrodynamics model needs the surface touching the water. These are different representations of the same design.

2. Is OpenSCAD a Reasonable Ground Truth?

For brainstorming and simple parametric geometry, absolutely. OpenSCAD is especially useful when your designs consist of repeatable pontoons, columns, decks, beams, and straightforward Boolean shapes. Its text-based format also works well with AI assistance and version control.

Its limitations become important when moving into engineering analysis:

• STL contains triangles, not engineering concepts such as “this is a 6 mm plate” or “this edge is welded to that beam.”
• Curves become faceted. A coarse export can affect displacement, waterplane properties, and calculated loads.
• OpenSCAD is not primarily a boundary-representation CAD system with native STEP/BREP engineering geometry.
• Thin walls that print well are not automatically good FEA geometry.
• A model can look correct while containing overlaps, internal faces, or tiny features that make meshing difficult.

You do not need to rewrite everything immediately. Your existing OpenSCAD modules can remain the first geometry generator.

3. How I Would Structure the Project

3.1 Separate design facts from modeling choices

Keep these categories distinct:

• Design: dimensions, component locations, plate thicknesses, materials, ballast tanks, payloads.
• Operating condition: loading case, water density, draft and trim, ballast state, moorings.
• Analysis settings: panel size, FEA element size, CFD resolution, wave periods and headings.
• Manufacturing settings: print scale, split locations, clearances, alignment pins, minimum printable walls.

For example, making a model’s wall thicker so it can be printed should not silently increase the assumed full-scale aluminum thickness.

3.2 Use one coordinate system and explicit units

A workable convention is:

• Full-scale dimensions stored in meters; masses in kilograms.
• X: forward; Y: port/left; Z: upward.
• A fixed design origin, with water level and body pose specified by the operating condition.
• For a Capytaine export, transform the model so the undisturbed free surface is at Z = 0, following the solver’s conventions.
• For printing, apply the scale and convert meters to millimeters only at export.

At 1:50 scale, a 10 m full-scale length becomes 10 × 1000 / 50 = 200 mm. STL itself does not reliably communicate units, so record them in the export manifest.

3.3 Define assemblies explicitly

Yes, there is a good way to specify how separate files fit together: each part should have a local coordinate system, and each instance should have a recorded transform into the full assembly.

An illustrative JSON assembly fragment:

{
  "units": "m",
  "axes": {"x": "forward", "y": "port", "z": "up"},
  "components": {
    "pontoon_A": {
      "generator": "pontoon",
      "length": 12.0,
      "width": 2.0,
      "height": 2.5,
      "plate_thickness": 0.006,
      "material": "aluminum_candidate"
    }
  },
  "instances": [
    {
      "id": "port_pontoon",
      "component": "pontoon_A",
      "translation_m": [0.0, 4.0, 0.0],
      "rotation_deg_xyz": [0.0, 0.0, 0.0]
    },
    {
      "id": "starboard_pontoon",
      "component": "pontoon_A",
      "translation_m": [0.0, -4.0, 0.0],
      "rotation_deg_xyz": [0.0, 0.0, 0.0]
    }
  ]
}

Document where each component’s local origin is. Also document the rotation convention; for more complicated assemblies, a 4×4 transformation matrix avoids ambiguity about rotation order.

OpenSCAD does not need to read this JSON directly. A short Python script can write a generated parameters.scad and assembly calls.

3.4 In OpenSCAD, organize geometry as modules

// parts/pontoon.scad
module pontoon(length_m, width_m, height_m) {
    // Full-scale design geometry, with numerical units in meters.
    // Replace this placeholder with your actual hull shape.
    cube([length_m, width_m, height_m], center=true);
}

A master assembly can use these modules and apply the recorded transforms. Separate export wrappers can select one component or one print segment.

Keep physical components and print segments separate. One full-scale pontoon might require six print segments, but it is still one pontoon in the hydrodynamic model. Print seams, pins, and screw holes should normally be excluded from engineering exports.

3.5 Suggested directory layout

seastead/
  design/
    parameters.json
    assembly.json
    materials.json
    load_cases.json

  generators/
    build_scad.py
    build_hydro_mesh.py
    build_structure.py

  cad/
    parts/
    assembly.scad
    print_exports/

  analysis/
    capytaine/
    fea/
    cfd/

  tests/
    geometry_checks/
    material_coupons/
    tank_results/

  build/
    design_001/
      print/
      hydro/
      structure/
      manifest.json

Use Git for the source files. Each export should record the design revision, parameter set, units, scale, software versions, and relevant mesh settings. That lets you connect a tank test to the exact digital design that produced it.

4. Recommended Open-Source Software

If choosing a new long-term code-first CAD foundation, I would evaluate CadQuery or build123d. Both retain much of the “AI helps write the model” workflow you like, while producing engineering CAD geometry as well as printable meshes.

However, STEP export is not a magic FEA button. You still need to decide which parts become shells, beams, solids, and connections.

5. Capytaine: Probably Your Best Next Step

Capytaine uses a boundary-element method for linear potential-flow wave–body interaction. It is much less computationally demanding than fully resolved free-surface CFD and is well suited to exploring:

• Wave excitation forces.
• Added mass and radiation damping.
• Response versus wave period and heading.
• How spacing, draft, column size, and pontoon geometry affect behavior.
• Wave-field visualization within the linear model.

What to generate

Generate a clean wetted-surface panel mesh, preferably directly from the parameters for simple shapes. Do not automatically reuse the finest printable STL.

• Remove internal walls, print details, and duplicate surfaces.
• Check panel normals and mesh quality.
• Intersect the body with the selected free surface correctly.
• For the usual surface-piercing-body formulation, do not add an ordinary body-panel cap across the waterplane just to make the mesh watertight. Special numerical lid treatments are a separate issue.
• Run a mesh-convergence check, especially near waterlines, narrow gaps, and small columns.

The CAD model alone does not determine motion

To calculate response amplitude operators (RAOs), you need mass, center of gravity, rotational inertia, hydrostatic restoring, and any additional damping or mooring stiffness. Check floating equilibrium first.

In simplified frequency-domain notation, a coupled rigid-body response calculation has the form:

[ -ω²(M + A(ω)) + iωB(ω) + C ] ξ = Fexc(ω)

Here, the matrices include the relevant inertia, damping, and restoring terms; Fexc must be normalized consistently with the chosen wave amplitude. The imaginary sign depends on the time convention. Capytaine provides core hydrodynamic quantities, but a complete response analysis still requires those system definitions.

For multiple floats, decide whether they form one rigid body, are separate articulated bodies, or require a flexible-body model. This physical decision matters more than whether the CAD assembly contains one file or ten.

A productive comparison is to sweep wave periods and headings and plot heave, roll, pitch, and deck-edge vertical motion. Look for resonances and inadequate clearance, then investigate those cases in the tank or with higher-fidelity methods.

6. FEA: Build a Structural Model, Not Just a Solid Mesh

For an aluminum seastead, a large part of the structure will likely be thin plating and stiffeners. Meshing every plate with solid tetrahedra can be unnecessarily expensive and inaccurate if the thickness is poorly resolved.

A better preliminary approach is often:

• Shell elements: hull plating, bulkheads, decks, larger webs.
• Beam elements: suitable stiffeners and framing members.
• Solid elements: selected joints, brackets, and local details.

The common parameters should generate midsurfaces, member centerlines, thickness assignments, and connection locations. These are engineering representations that cannot generally be recovered reliably from STL.

Can FEA software use OpenSCAD output?

Yes, indirectly. A clean, watertight STL can sometimes be processed into a volume mesh using Gmsh or other meshing tools, then used by an FEA solver. But it is a relatively fragile route for complicated thin-walled structures. Creating suitable surfaces directly, or exporting STEP from a CAD kernel, is usually more maintainable.

Useful preliminary load cases

• Still-water buoyancy balanced against weight and payload.
• Asymmetric payload or ballast.
• Global bending and twisting from uneven buoyancy and wave loading.
• Loads in connections between floats, columns, and deck.
• Local external pressure, plate bending, and buckling.

A floating structure should not be arbitrarily clamped to the ground. Use balanced loads with an appropriate free-body treatment, inertia relief where supported, or carefully chosen minimal constraints that remove rigid-body motion without creating fictitious load paths.

Hydrodynamic-to-structural coupling also requires care: an RAO is not itself a pressure load. Mapping wave pressures into FEA should be consistent with motion-induced inertial loads and the phase of the load case.

At this stage, begin with beam calculations and simple FEA models to compare concepts. Detailed weld fatigue, imperfections, corrosion allowances, and certification-level load combinations can come later with the naval architect.

7. Froude-Scaled Wave-Tank Models

For gravity-dominated free-surface behavior, Froude scaling is the usual starting point. Let:

λ = model length / full-scale length

For a 1:50 model: λ = 1/50

With the same gravitational acceleration and approximately the same water density:

For example, a 10-second full-scale wave period corresponds to about 1.41 seconds in the tank. A 5 m wave height corresponds to 100 mm, measured crest-to-trough.

Ballast and inertia matter

Matching the outside shape and draft is not enough for a useful motion experiment. Aim to match:

• Total mass.
• Center of gravity.
• Roll, pitch, and yaw mass moments of inertia—or equivalently, scaled radii of gyration.
• Relevant mooring or connector behavior.

Distribute ballast rather than placing all of it at one convenient point. If the empty print already exceeds the target mass, the model cannot be corrected by adding ballast; the print design or scale must change.

Freshwater-versus-seawater density differences should be included when setting target mass and loads. Reynolds number, surface tension, viscous damping, tank-wall effects, and reflected waves do not automatically follow Froude similarity.

8. Can a 1:50 Plastic Model Say Anything About Aluminum Strength?

Yes, but mainly as a controlled comparison or model-validation experiment—not as a direct proof of full-scale strength.

A small plastic model can reveal weak load paths, flexible connections, twisting, and some buckling tendencies. However, “the model survived waves” is not enough to establish that the aluminum structure will survive corresponding full-scale waves.

8.1 Elastic stiffness similarity

For geometrically similar structures in linear elasticity, define:

λ = Lmodel / Lfull
e = Emodel / Efull

For similar strain and deflection/length:

Force ratio:     Fmodel / Ffull = e λ²
Pressure ratio:  pmodel / pfull = e
Moment ratio:    Mmodel / Mfull = e λ³
Deflection ratio: δmodel / δfull = λ

These rules assume corresponding load distributions, boundary conditions, scaled thicknesses, and sufficiently similar constitutive behavior, including Poisson’s ratio where important.

For illustration, if aluminum has an elastic modulus of about 69 GPa and your actual printed plastic measures 2 GPa:

e ≈ 2 / 69 ≈ 0.029

At 1:50:
Fmodel / Ffull ≈ 0.029 × (1/50)²
              ≈ 1/86,000

That is the force scale for elastic similarity in this example, not automatically the Froude force scale of 1/125,000.

8.2 Why plastic at 1:50 is interesting—but not automatically correct

To match both Froude loading and elastic deformation in a geometrically scaled structure using the same water density, the ideal modulus ratio is:

Emodel / Efull = λ

At 1:50, with Ealuminum ≈ 69 GPa:
Emodel ≈ 1.38 GPa

This is in the broad range of some plastics or printed constructions. So there is a legitimate basis for exploring a hydroelastic model.

But matching one modulus is not enough. You also need scaled effective bending/torsional stiffness, mass distribution, connections, and dynamic behavior. Printed plastics are often anisotropic, rate-dependent, and affected by temperature, water, and print settings.

8.3 Thin plating is likely the biggest obstacle

A 6 mm aluminum plate becomes only 0.12 mm thick at 1:50. That is generally impractical as a faithful structural element on ordinary filament printers.

If you substitute a 0.8 mm printed wall, you have changed the structural proportions dramatically. Plate bending stiffness depends approximately on thickness cubed, so modulus scaling alone no longer fixes the problem.

You can sometimes design a deliberately distorted model with calibrated equivalent stiffness, but then you are building an experimental analog, not simply shrinking the CAD.

8.4 Stiffness similarity is not failure similarity

Plastic and aluminum have different yielding, fracture, creep, fatigue, and joint behavior. Elastic buckling can sometimes be scaled under carefully controlled conditions, but it is highly sensitive to geometry, imperfections, and boundary conditions.

A model that matches stiffness will generally not simultaneously match yield or ultimate failure loads. Printed layer separation is also not a useful analog for an aluminum weld failure unless specifically calibrated for that purpose.

8.5 Practical rules that make these tests useful

1. Separate wave-motion and structural models initially. Optimize one for mass/inertia and the other for measurable structural behavior.
2. Print test coupons with the same material, orientation, wall strategy, and settings as the structure.
3. Measure effective stiffness rather than using a generic filament datasheet.
4. Start with simple members and joints: a beam, a plate panel, and a representative connection.
5. Compare measured load–deflection curves with FEA of the actual printed specimen.
6. Use the calibrated modeling approach to analyze the aluminum version separately.
7. Consider larger-scale subassembly tests instead of printing the entire structure at 1:50 for strength testing.

9. CFD: Useful, but I Would Add It Later

OpenFOAM can work with STL surfaces from OpenSCAD. A common route is to use the body surface as input to snappyHexMesh, which creates a volume mesh in the surrounding domain.

That is useful interoperability, but the STL is only a small part of a valid CFD model. You must also address:

• Wave generation and absorption.
• Free-surface resolution and time-step convergence.
• Domain size and unwanted wave reflections.
• Body motion, mass properties, and mesh-motion strategy.
• Viscosity, turbulence, and possibly air effects.
• Moorings or constraints, where relevant.

Choose one OpenFOAM distribution and version, then use tutorials and wave-generation tools compatible with it. Mixing instructions from different versions is a frequent source of difficulty.

Before simulating a moving seastead, demonstrate that the chosen setup reproduces the requested wave height and period in an empty numerical tank. Then test a fixed simple body, and only then a moving body.

DualSPHysics is another option worth evaluating, particularly for overtopping or highly nonlinear free-surface behavior. It also needs convergence checks and physical validation; visually impressive splashes are not evidence of accurate loads.

10. An Efficient Staged Plan

Stage A — Keep your current CAD and add basic checks

• Refactor OpenSCAD into reusable component modules and a master assembly.
• Add a shared parameter/assembly file and export manifest.
• Calculate displacement, waterplane properties, approximate mass budget, and initial stability.
• Check that each design floats at a plausible draft and center of gravity.

These checks often eliminate bad concepts before any expensive simulation.

Stage B — Add Capytaine and controlled tank tests

• Generate simple wetted panel meshes directly from the design parameters.
• Sweep periods and headings; compare response and resonance trends.
• Run mesh-convergence checks on representative cases.
• Print selected designs with adjustable ballast.
• Measure incident waves and body motion; use decay tests to investigate natural periods and damping.

Stage C — Add preliminary structural analysis

• Create a beam/shell representation from the same dimensions.
• Use CalculiX, potentially through FreeCAD FEM, for a small set of transparent load cases.
• Check hand-calculation estimates against FEA.
• Test representative printed subassemblies if useful.

Stage D — Investigate specific nonlinear questions

• Use CFD for questions such as deck wetness, overtopping, slamming risk, or large relative motion.
• Validate against tank measurements where possible.
• Reserve high-resolution simulations for a few finalists rather than every design variant.

11. Make Automation Check the Models, Not Just Generate Them

AI-assisted code generation is a good fit for this workflow. Pair it with automatic checks so a plausible-looking model does not silently become a misleading experiment.

For every design revision, report:

• Overall dimensions and component positions.
• Displaced volume at the chosen waterline.
• Total mass, center of gravity, and inertia estimates.
• Whether buoyancy and weight balance.
• Unintended intersections or disconnected components.
• Whether the print is watertight and within the mass budget.
• Hydrodynamic mesh quality and panel-normal checks.
• Structural connectivity, thicknesses, material assignments, and load balance.
• Agreement between representations—for example, whether the CAD hull and hydrodynamic mesh have acceptably close displacement.

Keep simple benchmark cases: a box-shaped float with known displacement, a cantilever beam with a known deflection, and a documented hydrodynamic validation example. Those are valuable regression tests when AI changes the generators.

Bottom Line

For you right now: OpenSCAD + Python + Capytaine + Gmsh + CalculiX/FreeCAD FEM is a sensible open-source starting point. Add ParaView for visualization, and postpone CFD until you have a specific question that linear analysis and tank tests cannot answer.

For the longer term: consider CadQuery or build123d as the code-first CAD generator, especially if STEP geometry and structural model generation become central. You can migrate components gradually without discarding your OpenSCAD work.

The highest-value result before engaging the naval architect is not a huge mesh or a convincing animation. It is a traceable design with a plausible mass budget and stability, measured or calculated motion trends, understandable load paths, and a clear list of assumptions and unresolved risks.