```html Open-source wave + multibody + cable simulation options for a tensegrity seastead

Free / open-source simulation options for a cable-braced “tiny oil platform” seastead in waves

You want: (1) rigid bodies (mostly cylinders), (2) joints/pivots, (3) cables with tension-only behavior + snap loads, (4) waves that can become nonlinear (changing submergence from ~1/3 to nearly fully submerged legs), and (5) clear visualization/video.

Key engineering reality: there is no single open-source tool that is simultaneously “push-button easy”, “fully nonlinear waves + violent free-surface”, “accurate cable snatch loads”, and “fast”. The practical path is usually a two-stage workflow:

Fast screening with a multibody + mooring solver and a wave load model (often linear or semi-empirical Morison), to explore many geometries and find “likely failure” cases (slack, snatch, resonance).
High-fidelity nonlinear verification of a few worst cases using CFD (VOF) or SPH, coupled (or co-simulated) with the multibody/cable model, then visualize in ParaView/Blender.

About the methods (why BEM may fail for your case)

BEM (Boundary Element / potential flow) is typically linear, assumes inviscid/irrotational flow, and is best for moderate motions and shapes where wave-body interaction is dominated by radiation/diffraction. It often struggles when: drag dominates, members pierce the free surface, and submergence changes a lot (exactly what you described).
Morison-type models (inertia + drag per member) can be surprisingly useful for cylindrical legs if calibrated, but you must accept empirical coefficients and limited free-surface detail.
CFD (VOF free surface) is the “gold standard” for nonlinear waves, green water, slamming, complex submergence, but it is heavy and setup-sensitive (meshing, turbulence, time step).
SPH handles violent free-surface and large motions well, is often easier to “mesh” (no mesh), and can use GPUs effectively, but may need careful tuning for numerical dissipation, boundaries, and pressure noise.

Direct answers to your specific questions

1) Chrono::FSI-SPH vs BEM in Chrono

Project Chrono has multiple “worlds”:

Chrono multibody (rigid bodies, joints, contact) + various external force models.
Chrono FSI (SPH): a particle-based fluid (SPH). This is not BEM. It is a nonlinear fluid solver (with a free surface), and can represent changing submergence and strong drag effects much better than linear BEM—at the cost of compute and tuning.
Chrono hydrodynamics modules can be used with more “naval architecture style” approaches, but if you found BEM too linear, Chrono::FSI-SPH is the right Chrono direction to explore.

2) Blender for “accurate” simulation?

Blender’s built-in physics is primarily for animation/graphics, not validated marine engineering. It can be excellent for visualization (importing motion and force time series), but it is generally not a good choice as the core solver for wave loads + structural dynamics + cable snatch loads. A common workflow is: simulate in Chrono/OpenFOAM/DualSPHysics → export to ParaView or Blender for rendering.

3) WEC-Sim + MoorDyn

WEC-Sim is widely used and can make great videos, but it is MATLAB/Simulink-centric. It can be very capable for wave energy converter style multibody + moorings, but:

Cost is usually substantial for a non-student: MATLAB + Simulink + Simscape Multibody (and sometimes additional toolboxes). Pricing varies by region and quote; a realistic budget is often multiple thousands of USD upfront or per year.
It is not “open source end-to-end” even if some parts are open.

Given your “free/open-source” requirement, it’s reasonable to deprioritize WEC-Sim unless you later decide the productivity is worth paying for.

Comparison table (open-source / free options)

Legend for “accuracy for your case” (cylinders + pivots + cables + nonlinear waves / changing submergence): High = can be high-fidelity if set up well; Medium = useful for screening/design iteration; Low = likely insufficient for your stated needs.

Option	Core method	Best for	Accuracy for your seastead case	Time to “first useful sim” (with Claude/Cursor help)	Effort to change to a new geometry	Visualization / video	YouTube examples (search links, not specific videos)
Project Chrono + FSI (SPH) (Chrono::FSI-SPH)	SPH free-surface fluid + Chrono multibody (joints/constraints) in one framework	Nonlinear waves, large motion, changing submergence; direct coupling to pivots/joints; GPU/CPU capable	High potential for your “legs go from 1/3 submerged to nearly fully submerged” question. Cable snatch: good if you implement/enable a proper cable model (or couple a line dynamics library).	2–6 weeks to get: wave tank + floating multibody + constraints + logging tensions reliably. (If you already got Chrono working, likely on the shorter end.)	Medium: once your pipeline exists (geometry import, constraints, cable definitions), variants are fairly fast.	ParaView output is common; Blender rendering via exported meshes/CSV is straightforward.	Search: Chrono FSI SPH free surface
DualSPHysics	SPH free-surface CFD (GPU-accelerated), widely used in coastal/ocean engineering demos	Violent free-surface, wave impact, sloshing, complex body motions; very strong visualization ecosystem	High for nonlinear wave/body interaction if configured well. For cables with snap loads: you may need coupling or custom implementation (not its main focus).	1–4 weeks to get a wave tank + floating bodies running. 4–10+ weeks if you must add robust tension-only cable dynamics with failure criteria.	Medium: geometry changes are easy; adding/changing constraints and custom cable logic is the harder part.	Strong built-in post-processing; ParaView commonly used.	Search: DualSPHysics wave tank floating body
OpenFOAM (e.g., `interFoam`, `olaFlow` add-ons, overset meshes)	Finite Volume CFD + VOF free-surface (Eulerian mesh)	High-fidelity nonlinear waves, diffraction, viscous drag, slamming; “engineering-grade” CFD when done carefully	High fluid accuracy potential. Multibody + cables: needs coupling (custom, or external co-sim). Harder to do “tensegrity + snapping cables” cleanly.	3–8 weeks to get a correct wave tank + 6DOF body motion for simple bodies. 2–4+ months to robustly couple complex multibody + multiple cables with failure logic.	Medium–High: once the meshing + motion framework exists, geometry changes still require re-meshing and stability checks.	ParaView is first-class for OpenFOAM; Blender possible for rendering.	Search: OpenFOAM interFoam wave tank floating body 6DOF
REEF3D	CFD for free-surface waves (often used in coastal engineering), typically VOF/level-set style methods depending on version	Wave-structure interaction, coastal/ocean CFD cases, good at wave generation/absorption setups	High for fluid/wave physics. As with OpenFOAM: complex multibody joints + cable snatch may require extra work/coupling.	4–10 weeks for a working wave + floating body setup, depending on familiarity and desired coupling.	Medium once templates exist; still CFD setup-heavy.	ParaView-friendly outputs.	Search: REEF3D wave structure interaction
Proteus (open-source CFD for free-surface)	FEM/variational-style CFD frameworks (free-surface capable)	Research-grade CFD with Python-driven workflows; can be attractive if you like scripting everything	Medium–High potential, but depends heavily on your setup and the maturity of wave + rigid-body coupling for your exact case.	4–12 weeks to become productive; longer if you need custom coupling for joints/cables.	Medium if you build parametric Python scripts early.	ParaView compatible.	Search: Proteus CFD free surface waves
Capytaine + MoorDyn (Python workflow)	Capytaine: linear potential flow (BEM) hydrodynamics; MoorDyn: dynamic mooring/lines (lumped mass)	Rapid iteration, frequency-domain/linear hydrodynamics + realistic line dynamics; great for “many design variants” early on	Medium for screening. Likely insufficient alone for your “large submergence change + drag-dominated tiny-platform” regime unless you augment with Morison/drag and/or nonlinear corrections.	3 days–3 weeks to get something useful (this is one of the fastest to first plots). Getting it “trustworthy” for your nonlinear regime is the hard part.	Low–Medium effort: geometry changes are easy and scriptable; huge advantage here.	You can generate clean videos by exporting motions to Blender/ParaView. (BEM itself won’t “look like CFD”.)	Search: Capytaine hydrodynamics Search: MoorDyn dynamic mooring simulation
MoorDyn + your own wave loading model (Morison / strip theory / custom)	Line dynamics (tension-only, snatch loads), plus external forcing you compute	Directly answering: “when do lines go slack, when do snatch loads exceed break strength?”	Medium overall, but can be high for cable loads if wave excitation forces are modeled well. Fluid loads are the weak link unless you calibrate.	1–3 weeks to a working prototype (fast!). Ongoing calibration/validation effort.	Low effort to try many geometries because the model is parametric.	Motions/line tensions plot easily; for videos you export body transforms to Blender/three.js.	Search: MoorDyn example simulation
MBDyn + external hydrodynamics	Multibody dynamics solver (very good at constraints), often used in wind/turbine/structures; can co-sim with other solvers	Complex joints/constraints + cables/structural dynamics; good candidate if your main focus is mechanical system behavior	Medium unless coupled to a strong wave solver. Excellent for the multibody/cable part; fluid part must come from elsewhere.	2–6 weeks to become productive for multibody; longer if you build robust wave coupling.	Medium (good once parameterized).	Export results to ParaView/Blender.	Search: MBDyn multibody simulation
Blender (physics)	Game/animation physics (rigid bodies, constraints) with artist-oriented solvers	Concept visualization, explainers, “what moves where” at a qualitative level	Low for engineering accuracy in wave loads, damping, and snap tension prediction.	Hours–days to get something moving that looks right.	Low effort for variants.	Best-in-class rendering.	Search: Blender ocean rigid body physics

What I would recommend for your specific goals

Recommended “fast-to-truth” path (open-source)

Stage A (screening / design iteration):
Use MoorDyn (for line dynamics + snatch loads) + a multibody solver (Chrono or MBDyn) with a wave force model:
- If your legs are mostly cylindrical: start with a Morison model (inertia + drag) per member, including added mass and drag coefficients, and incorporate time-varying submergence and free-surface kinematics.
- This stage answers quickly: slack events, peak tensions, resonance, sensitivity to geometry/cable pretension.
Stage B (high-fidelity nonlinear verification):
For the worst cases found above, run either:
- Chrono::FSI-SPH if you want an integrated multibody+fluid environment and are okay tuning SPH; or
- DualSPHysics if you want strong wave tank examples and GPU acceleration, accepting that cable dynamics may need extra work; or
- OpenFOAM (interFoam) if you want “classical CFD”, accepting much heavier setup/coupling complexity.
Visualization: use ParaView for engineering review; export to Blender only for presentation-quality videos.

Why this matches your unusual geometry

Your structure is draggy and free-surface piercing, with large changes in submergence. That pushes you away from “pure BEM” as the final answer.
You care about failure modes (slack → snap). That pushes you toward a solver with explicit, time-domain line dynamics (MoorDyn-like) and good rigid-body constraints.
You have a very strong workstation, so CFD/SPH verification runs are realistic.

How hard is it to run a second/third/fourth design variant?

Scriptable, parametric approaches (Python generating bodies/cables/joints) pay off massively. If you invest early in a parametric “geometry + connections” description (JSON/YAML/Python), then changing designs becomes “edit parameters and rerun”.
Capytaine+MoorDyn / MoorDyn + custom loads: typically the easiest to iterate many variants quickly (hours to a day per new configuration once your scripts exist).
Chrono::FSI-SPH: moderate iteration cost. Once your import/definition pipeline is solid, new variants are feasible (often a day or two), but you may re-tune SPH resolution/time step for stability.
OpenFOAM: iteration cost is higher because meshing and numerical stability can change with geometry (often days per variant unless the geometry changes are minor and your meshing is automated).

Practical notes for your “cable slack / snatch load / break” requirement

Slack detection: you need a tension-only element model (no compression). MoorDyn does this naturally; many general multibody “spring” elements do not unless configured.
Snatch loads depend on: line axial stiffness, damping, line inertia, fairlead geometry, and time step. You’ll want:
- line material model (EA, damping),
- possibly segment mass distribution,
- small enough time steps near slack-to-taut transitions.
Breaking: simplest is a maximum-tension criterion with optional “cycle counting” later. Implement as: “if T > T_break for N steps → detach / replace with no-force”.

How to make videos like your YouTube example (general pipeline)

Run simulation (Chrono/DualSPHysics/OpenFOAM) and export:
- rigid body transforms vs time (CSV),
- cable node positions/tensions vs time,
- free surface mesh/particles (VTK) if CFD/SPH.
Review in ParaView for engineering debugging (forces, tension peaks, motions).
Render in Blender (optional):
- import body transforms (or bake as keyframes),
- draw cables as curves with thickness driven by tension,
- overlay graphs (tension vs time) if desired.

If you tell me a few choices, I can suggest a concrete “first simulation” plan

If you answer the questions below, I can propose a very specific stack (and a staged plan that minimizes wasted work):

Do you want to start with SPH (Chrono/DualSPHysics) or with a fast screening model (MoorDyn + Morison) first?
Do you need fully 3D directional waves, or is long-crested (2D) wave direction sufficient initially?
Do you have target sea states (e.g., Hs/Tp ranges) and a rough mass/CG/inertia estimate for the platform?
Do you want the legs to be rigid relative to the platform except for pivot joints, or do you also want structural flex?

Notes / transparency: I did not paste specific YouTube video IDs because I cannot reliably verify exact URLs offline. The links provided are YouTube search queries that will surface relevant examples for each package.

```