Here's the full comparison as a self-contained HTML page — save it as `seastead-sim-tools.html` and drop it straight into your site. It covers a master comparison matrix, per-tool profiles with time-to-first-simulation estimates (assuming Claude Code assistance), direct answers to each of your questions, a recommended multi-fidelity workflow, runtime expectations for your GPU box, and a first-30-days plan. ```html Free Simulation Software for Your Seastead — Comparison

Choosing Free Simulation Software for Your Seastead

A comparison of open-source and free tools for wave‑interaction simulation — tuned to your foil‑leg trimaran seastead, your GPU workstation, and a Claude‑Code‑driven workflow.

The short answer

No single free tool does everything you asked for. The winning setup is a two-tool core plus helpers:

PRIMARY: DualSPHysics FAST LOOP: Capytaine + MoorDyn + small Python 6‑DOF VALIDATOR: OpenFOAM (+ olaFlow) MOVIES: Blender (render only) STRUCTURE: CalculiX / Code_Aster (later) EXCLUDED: WEC‑Sim (paid MATLAB stack)

Key insight for your program: your central unknown — how much the foil legs and heave plates damp heave/roll as submergence changes — is exactly where linear BEM fails and where SPH/CFD shine. Plan to extract damping from numerical decay tests in DualSPHysics, then feed those coefficients back into the fast Capytaine/MoorDyn loop for long‑duration statistics. That hybrid is how professional offshore teams do it.

Your design, as understood (simulation‑relevant parts)

ItemValue / note
Container (shipping envelope)45‑ft High Cube: 7.7 × 8.9 × 44.6 ft, ≤ 62,000 lbs
Habitat frameEquilateral triangle, 44.0 ft sides; walls 7 ft tall; enclosed living area
Walkway3 ft wide, aluminum grating, railing, diagonal braces; 1 ft above wall bottom; two aft doors
Legs / foils ×321.5 ft long, NACA 0035, 8.5 ft chord (tail trimmed to ≈8.0 ft, buoyancy ≈ unchanged); 14.5 ft tall, 50% submerged → draft ≈ 7.25 ft; leading edges face forward; internal ladders topside; airtight compartments; no through‑hulls
Buoyancy target27,500 lbf at waterline (∇ ≈ 12.5 m³)
Waterplane sanity check3 foil waterplanes ≈ 60 ft² total → 1 ft heave ≈ 3,700 lbf ≈ 13–14% of displacement — consistent with your "1/7th" figure ✓
Batteries≈25% of displacement, low in legs (≈3.1 t LiFePO₄ → order 0.5 MWh); triple‑redundant inverters
Thrusters6 × 1.5 ft rim drives, fixed forward orientation (excluded from sims for now, per your scope)
Heave platesBolt‑on, lower legs — a prime subject of the damping study
Station‑keeping3 corner tendon pairs to helical screws, ~3 ft pull‑down, Caribbean micro‑tides
Dinghy14 ft RIB + electric outboard, towed astern on two ropes (defer)

All solvers below work in SI units — build one ft↔m / lb↔kg converter module early and unit‑test it (classic silent killer).

Master comparison matrix

ToolMethodFidelity for your problemAnswers leg‑damping question?GPUTruly free?Time to 1st result †Reuse ‡Role
CapytaineLinear potential‑flow BEM (Python)Low–Med (small waves)No — add drag by hand—Yes (GPL)1–3 days●●●●●RAOs, natural periods, screening
MoorDyn + Python 6‑DOFLump‑mass lines + rigid‑body time domainMed (lines nonlinear; hydro linear)Partly—Yes1–2 weeks●●●●●Tendons, pretension, slack checks
DualSPHysicsGPU SPH CFDHigh (breaking, slamming, green water)YesNVIDIA ✓Free research license *1–2 weeks●●●●○Primary survival simulator
Chrono::FSI‑SPHGPU SPH + multibodyHighYesNVIDIA ✓Yes (BSD)2–4 weeks●●●○○Alternate to DSPH; best contacts/coupling
HydroChronoBEM coefficient tables in Chrono TDLow–MedNo—Yes1–2 weeks●●●●○Chrono ecosystem with linear hydro
OpenFOAM + olaFlowFV CFD (VOF)High (best viscous detail)YesCPU‑mostlyYes (GPL/LGPL)3–5 weeks●●○○○Gold‑standard validation cases
REEF3D ::CFD / ::FNPFFV CFD / fully‑nonlinear potential flowHigh / Med‑HighYes / partlyCPU (MPI)Yes (GPL)3–5 weeks●●○○○Alternative; FNPF is a mid‑fi sleeper
WEC‑SimLinear TD in SimulinkLow–MedNo—✗ paid stackexcluded—See cost box — agree, strike it
Blender (physics)Game / artist physicsNone validatedNosomeYesinstant—Do not use for engineering answers
Blender (render)Renderer + Python APIn/an/aGPU render ✓Yes2–4 days●●●●●Cinematic videos from solver output
OpenFAST / HydroDynOffshore TD frameworkMed (linear + Morison options)Partly (Morison legs/plates)—Yes (BSD)2–4 weeks●●●○○Pragmatic TD glue alternative
HOS‑NWT / OceanWave3DNonlinear wave‑field factories(inputs for other solvers)Indirect—Yes (research)advanced●●○○○Extreme / focused wave generation
CalculiX / Code_AsterStructural FEAn/an/aCPUYes (GPL)1–2 weeks (later)●●●●○"What breaks first" from load envelopes

* DualSPHysics is zero‑cost for research after registration, but is not OSI‑approved open source; commercial deployment requires an agreement with the developers.   † Assumes you + Claude Code at a motivated pace — the bottleneck is learning each tool's physics setup, not the scripting.   ‡ Relative ease of rerunning with a modified hull.

Tool profiles

Capytaine keep forever

Method
Linear potential‑flow BEM, frequency domain (modern Nemoh successor, pure Python)
Install
pip install capytaine
Gives you
Added mass, radiation damping, Froude‑Krylov + diffraction forces, RAOs, multibody
Speed
Full frequency sweep in minutes on a laptop
AI‑assist fit
High — pure Python
Strengths, limits, links

Strengths: fastest route to natural periods and RAOs; run hundreds of design variants per day; perfect for checking your waterplane stiffness and comparing leg placements; feeds time‑domain tools.

Limits: inviscid — completely misses the viscous/form damping from your legs and heave plates (your key question); linear — wrong once legs emerge, slam, or the waterplane changes; small‑amplitude assumption.

Role: baseline + cross‑check. Low‑amplitude SPH RAOs should converge toward Capytaine's — a powerful correctness test of your SPH setup.

github.com/mancellin/capytaine

MoorDyn + your 6‑DOF glue core

Method
Lump‑mass cable dynamics; tendons, lines, clumps; official Python bindings
License
Open source (permissive); also embedded in OpenFAST and WEC‑Sim
Gives you
Tendon dynamics, pretension sizing, slack‑and‑snap detection, snap loads
AI‑assist fit
High
The missing piece, and three ways to fill it

Nobody ships a ready‑made "floating seastead" time‑domain glue joining BEM coefficients + moorings. Three options:

  1. Small Python integrator (~200 lines: RK4 rigid‑body 6‑DOF, interpolated Capytaine coefficients, MoorDyn calls each step). Claude Code drafts this in days. Most educational, fully yours.
  2. OpenFAST used platform‑only (rotor zeroed) — more scaffolding, but battle‑tested.
  3. HydroChrono — BEM tables applied inside Chrono's multibody engine.

Remember: the hydro stays linear unless you inject damping measured from SPH/CFD decay tests — that injection is what makes this fast loop trustworthy in big seas.

github.com/FloatingArrayDesign/MoorDyn

DualSPHysics primary simulator

Method
Lagrangian SPH particle CFD, GPU (CUDA / NVIDIA required — you have one)
License
Zero‑cost research license (registration); not OSI open source; commercial use needs agreement
AI‑assist fit
High — XML case files + CLI + Python post‑processing
Time to 1st result
Demo 3–7 days; full seastead 2–3 weeks
Reuse, new hull
1–2 days (swap STL, edit XML)
Why it fits, and watch‑outs

Built for exactly your scenarios: breaking and focused waves, slamming, green water, deck wetness, large 6‑DOF body motions, floating bodies, mooring lines, wave/pressure/force gauges, JONSWAP & Pierson‑Moskowitz irregular seas, NewWave‑style focused groups. Post‑processing to ParaView is a built‑in pipeline (GenCase → DualSPHysics → PartVTK → ParaView), plus ComputeForces/MeasureTool.

Watch‑outs:

  • Runtime scales with particles × duration. Strategy: focused 30–60 s survival events first; 3‑minute irregular runs overnight; full hour‑long sea states only for finalists.
  • Pressure fields are noisy — use averaged gauges, not instantaneous peaks, for loads.
  • Your perforated grating walkway is awkward for particles: model it as a solid slab for global loads; treat wave transparency and uplift separately (analytically, or an OpenFOAM spot‑check).
  • Always run a particle‑size convergence study before quoting numbers.

Suggested first milestones: stock floating‑box demo → your STL in regular waves → free‑decay tests (with/without heave plates) → focused‑wave ladder.

dual.sphysics.org

Project Chrono: FSI‑SPH vs HydroChrono strong alternate

Chrono::FSI
GPU SPH particles coupled to Chrono's multibody solver — not BEM, fully nonlinear
HydroChrono
Add‑on applying BEM coefficient tables (WAMIT/Nemoh/Capytaine) inside Chrono — this one is BEM‑based
License
BSD (Chrono core)
AI‑assist fit
Medium — C++ builds, smaller marine community
Time to 1st result
2–4 weeks
When to prefer Chrono

Chrono's superpower is multibody + contact. When you get to the two‑seastead walkway, dinghy crane/rope mechanics, or anything with collisions and couplings, Chrono::FSI‑SPH is architecturally nicer than DualSPHysics. Costs: heavier build (CMake + CUDA), fewer marine conveniences (wave spectra, gauge tooling) so more DIY, and fewer published floating‑body benchmarks to copy. Sensible plan: start with DualSPHysics; adopt Chrono later for the connected‑seastead phase.

projectchrono.org (FSI ships with the source as the chrono_fsi module; search "HydroChrono" on GitHub for the BEM add‑on)

OpenFOAM + olaFlow validator, not daily driver

Method
Finite‑volume RANS/LES with VOF free surface; floating bodies via sixDoFRigidBodyMotion (interFoam) or overset (overInterDyMFoam)
Waves
olaFlow boundary conditions: regular/irregular spectra, focusing, active absorption
License
GPL/LGPL, fully open (openfoam.org / openfoam.com)
AI‑assist fit
Medium‑high — dict files template well; meshing debug is human work
Time to 1st result
3–5 weeks
Where it wins, where it hurts

Wins: the only tool here that properly resolves boundary layers, vortex shedding off the foil trailing edges, and heave‑plate separation damping. Ideal for: extracting equivalent linear + quadratic damping coefficients; validating the 2–3 worst DualSPHysics cases; pressure maps for structural FEA.

Hurts: meshing three foils + frame + plates + walkway with snappyHexMesh is the hard part; CPU‑MPI means your GPU idles; a 60 s storm event can take days on ~32 cores; every redesign means remesh + retune.

openfoam.org · openfoam.com · github.com/phicau/olaFlow

REEF3D (::CFD and ::FNPF) worth watching

Method
GPL finite‑volume CFD (MPI C++) plus REEF3D::FNPF — a fully nonlinear potential‑flow solver
Heritage
Strong published record in wave‑impact / coastal‑structure research (NTNU lineage)
AI‑assist fit
Medium
Time to 1st result
3–5 weeks
Why it's on the list

REEF3D::FNPF is interesting as a mid‑fidelity sleeper: it captures wave nonlinearity far beyond linear BEM at a fraction of CFD cost — potentially a good fit for your "legs mostly submerged but occasionally emergent" regime, though without viscosity (so still pair it with measured damping). The CFD module competes with OpenFOAM but has a smaller community and fewer floating‑body tutorials. Linux‑native.

github.com/reef3d/reef3d

WEC‑Sim excluded — cost

Status
Code is open source; the runtime is not
Requires
MATLAB + Simulink + Simscape + Simscape Multibody (Octave will not run Simulink/Simscape — no free workaround)
Hydro
Linear BEM coefficients (+ optional nonlinear Froude‑Krylov patch)
Cost estimate (non‑student, Anguilla)
ComponentApprox. list, USD/yr (individual subscription)
MATLAB$900 – $1,200
Simulink$2,300 – $3,000
Simscape (base)$700 – $1,000
Simscape Multibody$1,000 – $1,500
Total≈ $4,900 – $6,700 / year

Ballpark list pricing; MathWorks sells worldwide via its web store in USD (no local Anguilla reseller discount known; no student pricing applies). Verify current prices at mathworks.com/store. Perpetual "Standard" licenses exist but cost more upfront.

You're right to strike it — and even if it were free, its linear hydro wouldn't answer your emerging‑leg damping question. MoorDyn, the good part, is free standalone anyway.

wec-sim.github.io

Blender — two very different roles movies & meshes only

Physics?
Still not engineering‑accurate — nothing fundamental has changed
Render
Excellent; GPU‑accelerated (Cycles/Eevee)
AI‑assist fit
High — full Python API
Viz pipeline time
2–4 days, reused forever
The honest assessment

Physics: Bullet rigid‑body has no hydrodynamics; Mantaflow and the paid FLIP Fluids addon produce beautiful but unvalidated forces; no wave spectra, no mooring, no engineering credibility. Any "buoyancy" is a scripted hack. Do not derive stability or loads from it.

What Blender is genuinely great for here:

  1. Authoring clean, watertight STLs of frame, legs, heave plates (metric units!) that every solver consumes.
  2. Cinematic visualization: solvers export 6‑DOF time series (CSV) and particle/field data (VTK) → a Python importer (written once with Claude Code) drives your seastead model through the simulated sea state → rendered MP4s that make failures obvious at a glance.

blender.org

OpenFAST / HydroDyn pragmatic middle path

Method
NREL's offshore time‑domain framework: HydroDyn (potential‑flow from BEM files, strip theory, or Morison members) + MoorDyn built in + rigid‑body platform 6‑DOF
License
BSD, fully open, Linux‑friendly
AI‑assist fit
Medium — turbine‑centric scaffolding to neuter
Time to 1st result
2–4 weeks
Why it's interesting despite being turbine gear

Platform‑only OpenFAST models are done in practice (zero the rotor). The gem for you: Morison members — a principled way to add viscous drag on the legs and heave plates that linear BEM lacks, without full CFD. Combined with native MoorDyn tendons, it's a credible intermediate between your fast loop and full SPH. Costs: awkward input format, documentation geared to turbines, and you'll spend time disabling rotor/tower machinery.

github.com/OpenFAST/openfast

Supporting cast & honorable mentions

Wave factories
HOS‑NWT / HOS‑Ocean (LHEEA, École Centrale de Nantes) — high‑order spectral nonlinear wave tanks; manufacture extreme focused/irregular wave fields to feed SPH/CFD. OceanWave3D — nonlinear potential‑flow wave model. Expert tools, huge payoff later.
Research CFD
Basilisk (basilisk.fr) — superb quadtree Navier–Stokes free‑surface research code; steep learning curve.
Structural FEA
CalculiX (dhondt.de) or Code_Aster (code-aster.org) — feed simulated pressure/load envelopes in, get stresses in frame joints, walkway brackets, tendon mounts out. This is how you answer "what fails first" physically.
Legacy
Nemoh — superseded by Capytaine; skip.
Utilities
Gmsh / Salome / Blender (meshing) · MeshMagick (hydro‑mesh cleanup + inertia) · BEMRosetta (convert BEM formats) · ParaView / pyvista (scientific viz) · MHKiT / wavespectra (sea‑state statistics)

Your questions, answered directly

1. "Project Chrono uses BEM… if we use Chrono::FSI‑SPH, then Chrono is not using BEM?"
Correct. Chrono itself is a multibody dynamics engine with no single hydro method. Its hydrodynamics come from add‑ons: Chrono::FSI is GPU SPH — not BEM, fully nonlinear, and it's the one that addresses your nonlinearity worry. HydroChrono is a separate add‑on that reads BEM coefficient tables and applies them as linear forces — that one is BEM‑based. Choose deliberately between them.
2. "Capytaine and MoorDyn, both from Python?"
Yes — Capytaine is pure Python (pip install capytaine), and MoorDyn has official Python bindings. The missing piece is the time‑domain glue between them; three routes: (a) a small Python 6‑DOF integrator Claude Code writes for you in days, (b) OpenFAST used platform‑only, (c) HydroChrono. Use BEMRosetta to shuffle coefficient formats. Caveat: the hydro remains linear until you inject damping measured from SPH/CFD decay tests.
3. "Blender — is the physics still inaccurate?"
Yes, still true. Bullet has no hydrodynamics; Mantaflow/FLIP (and the paid FLIP Fluids addon) are artist‑grade with unvalidated forces; no wave spectra or mooring. But Blender earns its place twice: authoring clean watertight STLs, and rendering cinematic videos from solver output (CSV 6‑DOF + VTK) via a Python importer written once. You get the "easy to understand" videos without lying to yourself about the numbers.
4. "WEC‑Sim + MoorDyn? Cost in Anguilla? Videos?"
WEC‑Sim's code is open source but requires paid MATLAB + Simulink + Simscape + Simscape Multibody: ballpark US$4,900–6,700/year list for individual subscriptions (USD web‑store pricing; no student discount applies; verify at mathworks.com/store). Octave cannot substitute. Strike it — and note that even free, its linear hydro wouldn't resolve your leg‑emergence question. It can animate bodies, but your video pipeline will be ParaView + Blender regardless. MoorDyn itself is free and excellent — use it standalone.
5. "Does DualSPHysics seem good for my needs?"
Arguably the best single fit. GPU SPH purpose‑built for wave‑structure interaction: breaking/focused waves, slamming, green water, large 6‑DOF motions, mooring lines, force/pressure gauges, JONSWAP/PM and focused seas. Zero‑cost research license (registration; not OSI — commercial use needs an agreement); requires your NVIDIA GPU. Plan runtimes (focused events first, overnight batches for irregular seas), run a particle‑convergence study, and model the grating walkway as a solid slab.
6. "OpenFOAM can use our compute cycles?"
It can — but mostly your CPU cores, not the GPU. It's the fidelity gold standard for viscous effects (leg vortex shedding, heave‑plate damping, boundary layers), yet meshing is painful and a 60 s storm event can take days on ~32 cores. Best role: validate the 2–3 worst SPH cases and extract damping coefficients for your fast loop. Pair with olaFlow for wave generation/absorption.
7. "Any other free software that might be better?"
Nothing replaces the two‑tool core, but these slot around it: REEF3D::FNPF (fully nonlinear potential flow — a genuine mid‑fidelity sleeper for your partially‑emergent legs), OpenFAST/HydroDyn (Morison members approximate leg/plate drag in time domain), HOS‑NWT / OceanWave3D (manufacture extreme nonlinear wave fields), Basilisk (research‑grade, steep), and — for the actual "what fails first" — CalculiX or Code_Aster structural FEA fed by simulated load envelopes.
8. "Compare options and estimate time to first simulation."
See the master matrix and profiles. Headline estimates with Claude Code assisting: Capytaine RAOs 1–3 days; Capytaine+MoorDyn+animations 1–2 weeks; DualSPHysics demo 3–7 days, full seastead 2–3 weeks; Chrono::FSI 2–4 weeks; OpenFOAM 3–5 weeks; REEF3D 3–5 weeks; Blender viz pipeline 2–4 days. The bottleneck is learning each tool's physics setup — the scripting is the easy part.
9. "Linux or Windows?"
Native Ubuntu 22.04/24.04 dual‑boot is recommended: DualSPHysics and Chrono's CUDA stacks are happiest natively; OpenFOAM/REEF3D/ParaView are trivial; Capytaine and Blender run anywhere. WSL2 works for Capytaine, CPU OpenFOAM, and Blender; CUDA‑under‑WSL2 functions for many stacks but native avoids friction. DualSPHysics also ships Windows binaries if you want a soft start before committing.
10. "After one model works, how hard is a different design?"
Build the pipeline parametric once: a YAML mass‑properties file + scripted STL regeneration (Blender/Gmsh) + per‑tool case templates. Then a new hull costs: Capytaine — hours; DualSPHysics — 1–2 days (swap STL, edit XML); Chrono — 2–4 days; OpenFOAM — 3–7 days (remeshing dominates); Blender viz — hours. Score table in the Reuse section below.

Recommended multi‑fidelity workflow

Phase 0 — Foundations (week 0). SI‑unit discipline; watertight STL set (frame, 3 legs, legs ± heave plates, walkway as solid slab); YAML mass properties (masses, CoG, inertias per battery‑SOC case); define the environment ladder (Hs ≈ 4 → 15 ft, Tp 6–12 s, JONSWAP; plus NewWave focused events); define failure metrics and sensor points (berths, helm, rail corners, tendon tops).
Phase 1 — Fast loop (weeks 1–2). Capytaine sweeps → RAO and natural‑period tables; hand‑check waterplane stiffness; MoorDyn tendon model; Python 6‑DOF integrator with placeholder quadratic drag; numerical decay tests; first matplotlib/pyvista animations.
Phase 2 — SPH survival lab (weeks 2–6). DualSPHysics: stock demo → your model → particle‑convergence study → free‑decay sims with and without heave plates (this is the experiment BEM cannot do) → focused‑wave ladder at rising Hs → overnight irregular‑sea batches. Extract: leg emergence and re‑entry slam velocities, deck/rail immersion, tendon slack events, acceleration spectra at sensor points. Render movies.
Phase 3 — Cross‑validate (weeks 4–8). Low‑amplitude SPH RAOs must approach Capytaine's — if not, fix the SPH setup before trusting extremes. OpenFOAM on the 2–3 worst cases; distill equivalent linear + quadratic damping coefficients and feed them back into the Phase‑1 fast loop → cheap long‑duration statistics.
Phase 4 — Structure (week 8+). Pressure/load envelopes → CalculiX or Code_Aster checks of frame joints, walkway brackets, tendon mounts → "what breaks first, at what sea state." Iterate Phases 1↔2 per design; reserve 3–4 for finalists.

Runtime expectations (planning ballparks)

Assumes one RTX‑class GPU and a 32‑core CPU. Real numbers swing wildly with resolution and convergence — treat as order‑of‑magnitude for scheduling, not quotes.

TaskToolSizeWall‑clock
Frequency sweep (RAOs)Capytaine~2k panel meshminutes
10‑min storm, reduced‑order TDPython + MoorDyn—seconds–minutes
Free‑decay suite (6 DOF × 3 amplitudes)DualSPHysics1–2 M particles2–8 h total
Focused wave event (~45 s)DualSPHysics3–6 M particles6–24 h
3‑min irregular sea, engineering resolutionDualSPHysics4–8 M particles1–4 days (overnight batches)
Same, halved particle size (convergence check)DualSPHysics×8 particles≈×10 cost — budget accordingly
60 s storm eventOpenFOAM15–40 M cells, 32 cores2–7 days
Comparable eventChrono::FSI‑SPHDSPH‑likesimilar order
Render 60 s cinematicBlender (GPU)—1–4 h

Seastead‑specific modeling tips

1. Decay tests are your key experiment. Prescribe an initial heave or roll offset, release in calm water, measure the log decrement → damping vs amplitude. Run with/without heave plates, with/without bilge‑keel strips on the legs. Hours per run, and it quantifies exactly the question linear BEM cannot touch.
2. Grating walkway. SPH and CFD see solids. Model the 3‑ft walkway as a solid slab for global loads; handle wave transparency via its open‑area ratio analytically, and if uplift worries you, one OpenFOAM spot‑case resolves it.
3. Accelerations at any point. From 6‑DOF histories: a_P = a_O + α×r + ω×(ω×r) (world frame). Implement once in post‑processing; place virtual accelerometers at berths, galley, helm, battery racks; report RMS and max against comfort (ISO‑2631‑style) and equipment limits.
4. Tendon slack is your parked‑mode failure. Track minimum tension per line; slack→snap is the danger. Require pretension > max downward impulse × 1.5–2 in simulation, and always run the one‑screw‑failed case.
5. Focused waves first, irregular for statistics. A focused wave group concentrates energy into one extreme crest — near‑worst‑case transient in tens of simulated seconds. Use irregular JONSWAP runs to gather statistics once survivors are identified.
6. Convergence before conclusions. Repeat one event at 2–3 particle sizes (SPH) or mesh densities (CFD); only quote numbers when deltas are within ~10%.
7. Validate the validator. At low amplitude your SPH RAOs must approach Capytaine's. If they don't, fix boundary spacing, time step, or gauge smoothing before believing extreme‑sea results.
8. One source of truth. A single YAML of masses/CoG/inertias generates configs for every tool; plus one unit‑tested ft↔m, lb↔kg converter module. These two artifacts prevent the classic silent errors.
9. Defer the dinghy ropes and twin‑seastead walkway. When ready: DSPH mooring lines or Chrono cables handle rope dynamics; the connected‑seastead coordinated‑thrust problem is a controls study that needs these plant models first — one reason Chrono is worth adopting later.
10. Report a fixed metric set per run. Max heel; deck‑edge immersion; rail submergence; leg emergence height and re‑entry speed; tendon min tension; peak/RMS accel at each sensor; green‑water events on roof. Identical metrics across designs is what makes comparisons honest.

Reusing the pipeline for new designs

ChangeCapytaineDualSPHysicsChronoOpenFOAMBlender viz
New hull / leg shapehours1–2 days2–4 days3–7 dayshours
Add/remove heave plateshourshours~1 day1–3 dayshours
Mass / inertia / battery changeminutesminutesminutesminutesn/a
New mooring / tendon layoutminutes–hours1–2 days1–2 days~1 dayn/a

These times assume the automation you build in Month 1 (parametric STL generation + case templates). Without it, multiply accordingly — the automation is the real product.

First 30 days (Claude Code in the passenger seat)

Week 1 — foundations

Week 2 — fast loop comes alive

Week 3 — your boat enters the tank

Week 4 — survival ladder

Stretch goals

``` A few notes on choices embedded in the page: I ranked DualSPHysics as your primary because your central unknown (variable leg submergence, heave-plate damping, slamming) is precisely where linear BEM breaks down, and DSPH is the most Claude-Code-scriptable GPU option; Capytaine+MoorDyn stays as the fast screening loop and cross-check; and WEC-Sim is excluded with a concrete cost estimate (~US$4.9–6.7k/yr) as you suspected. If you'd like, I can follow up with a starter Capytaine RAO script or a DualSPHysics case-template generator tailored to your triangle-plus-three-foils geometry.