Open-source and free tools for simulating a semi-submersible seastead with articulated legs, cables, and wave response
A small semi-submersible seastead (~36,000 lbs) with a 40×16 ft living platform, four 4-ft diameter × 24-ft long cylindrical legs/floats at 45° angles, connected by cables at the submerged ends. Key simulation requirements:
This is the single best option for your specific needs. Here's why:
Second choice: Capytaine + MoorDyn + custom Python time-domain solver — more manual assembly but very capable for hydrodynamics. Good if you find Chrono's build process frustrating.
Third choice: DualSPHysics — most visually impressive, handles nonlinear effects naturally, but steep learning curve and slow computation for design iteration.
| Criterion | Project Chrono (HydroChrono) |
Capytaine + MoorDyn + Python |
WEC-Sim + MoorDyn |
DualSPHysics | OpenFOAM | Blender (physics) |
|---|---|---|---|---|---|---|
| Cost | Free / Open Source | Free / Open Source | $$$ MATLAB required | Free / Open Source | Free / Open Source | Free / Open Source |
| MATLAB Cost Estimate | N/A | N/A | ~$3,500–$5,500/yr (MATLAB + Simulink + Simscape Multibody) |
N/A | N/A | N/A |
| Nonlinear Buoyancy (variable submergence) |
✅ Yes — mesh-based hydrostatics at each timestep |
⚠️ Partial — linear BEM; need custom nonlinear Froude-Krylov corrections |
⚠️ Partial — has nonlinear buoyancy option but still BEM-based |
✅ Fully nonlinear — SPH particles handle any submergence |
✅ Fully nonlinear — volume-of-fluid method |
❌ Not physically accurate |
| Articulated Joints (pivot legs) |
✅ Excellent — core multibody engine |
⚠️ Manual — must code joint constraints in your time-domain solver |
✅ Yes — via Simscape Multibody joints |
❌ Very difficult — SPH doesn't natively do articulated rigid bodies |
❌ Requires coupling with external solver |
⚠️ Has joints but physics is not accurate |
| Cable/Mooring Dynamics |
✅ MoorDyn built in | ✅ MoorDyn via Python | ✅ MoorDyn integrated | ⚠️ Limited — can add spring connections |
❌ Needs external coupling (MoorDyn) |
❌ No real cable dynamics |
| Snap Load Detection | ✅ Monitor MoorDyn tension vs. time; detect slack→tension transitions |
✅ Same — MoorDyn output analysis |
✅ Same | ⚠️ Possible with post-processing |
❌ Not practical | ❌ No |
| Wave Generation | ✅ Regular, irregular (JONSWAP, PM), user-defined |
✅ You generate via Python; very flexible |
✅ Built-in wave spectrum options |
✅ Excellent wave generation including breaking waves |
✅ Excellent via waves2Foam / olaFlow |
⚠️ Visual only — not real wave physics |
| 3D Visualization | ✅ Real-time 3D + video export |
⚠️ Must build with matplotlib/VTK/Blender post-processing |
✅ Simulink 3D visualization |
✅ ParaView — excellent fluid visualization |
✅ ParaView | ✅ Best visual quality possible |
| Python Scripting | ✅ PyChrono — full API | ✅ Native Python | ❌ MATLAB only | ⚠️ XML config + Python post-processing |
⚠️ Python utilities exist but core is C++ |
✅ Python scripting built in |
| AI Coding Help (Claude/Cursor) |
✅ Good — Python; documentation in training data |
✅ Excellent — pure Python; well-documented |
⚠️ Moderate — MATLAB; less AI coding support |
⚠️ Limited — XML config; less standard |
⚠️ Moderate — complex C++ dictionaries |
✅ Good — Python Blender scripting |
| Linux Support | ✅ Native | ✅ Native | ⚠️ Via MATLAB Linux | ✅ Native + GPU | ✅ Native (best on Linux) | ✅ Native |
| GPU Utilization | ⚠️ Optional (Chrono::GPU for granular, not needed here) |
N/A (CPU-based) | N/A | ✅ Core feature — GPU massively accelerates SPH |
⚠️ Some GPU solvers | ⚠️ GPU for rendering |
| Accuracy for This Design |
Good — engineering quality for concept stage |
Good — BEM hydro is industry standard |
Good — proven for wave energy converters |
Very Good — fully nonlinear physics |
Excellent — highest fidelity CFD |
Poor — not engineering grade |
| Time to First Simulation |
2–4 weeks | 2–3 weeks | 1–2 weeks (if you have MATLAB) |
3–6 weeks | 4–8 weeks | 1 week (but not accurate) |
| Time to Useful Engineering Results |
4–6 weeks | 4–6 weeks | 3–5 weeks | 6–10 weeks | 8–16 weeks | Never (for engineering) |
| Computation Speed (per simulation) |
Minutes to ~1 hour | Minutes (time-domain) + BEM pre-solve |
Minutes | Hours to days (even with GPU) |
Hours to days | Minutes |
Free & Open Source Python (PyChrono) C++ core Linux ✓ Windows ✓
Project Chrono is a physics-based simulation engine from the University of Wisconsin–Madison. It is fundamentally a multibody dynamics engine — exactly what you need for articulated rigid bodies with joints, cables, and constraints. HydroChrono is the module that adds hydrodynamic forces (wave excitation, radiation damping, hydrostatic restoring). MoorDyn is integrated for mooring/cable dynamics.
Search for "Project Chrono hydrodynamics" or "HydroChrono". Relevant videos:
Free & Open Source Pure Python Linux ✓ Windows ✓
Capytaine is a Python-based BEM (Boundary Element Method) solver for wave-body interaction — it computes the frequency-dependent hydrodynamic coefficients (added mass, radiation damping, wave excitation forces) for your geometry. MoorDyn handles cable/mooring dynamics. You then write a time-domain integration script in Python that combines these forces with rigid body dynamics to simulate motion in waves.
pip install capytaine — easiest install of any option.pip install moordynPaid — MATLAB Required MATLAB / Simulink Linux ✓ Windows ✓
WEC-Sim (Wave Energy Converter Simulator) is an open-source MATLAB/Simulink code developed by NREL and Sandia National Labs. It uses BEM hydrodynamic data (from Capytaine, WAMIT, or NEMOH), integrates multibody dynamics via Simscape Multibody, and includes MoorDyn for mooring lines.
WEC-Sim Documentation | GitHub
Free & Open Source C++ / CUDA GPU Accelerated Linux ✓ Windows ✓
DualSPHysics uses Smoothed Particle Hydrodynamics (SPH) — instead of solving equations on a grid, the water is represented as millions of particles. This naturally handles splashing, breaking waves, large motions, and complex geometry. GPU acceleration (CUDA) makes it practical.
Free & Open Source C++ Linux ✓ (native) Windows (WSL)
OpenFOAM is the gold standard open-source CFD (Computational Fluid Dynamics) toolkit. It solves the full Navier-Stokes equations on a 3D mesh. For marine applications, it uses a Volume-of-Fluid (VOF) method to track the free surface.
sixDoFRigidBodyMotion solver handles floating bodies.Free & Open Source Python scripting GPU rendering Linux ✓ Windows ✓
Blender is a 3D modeling, animation, and rendering tool. It has built-in physics engines for rigid body dynamics, cloth, fluid, and soft body simulation.
You were told correctly — Blender's physics simulations are not engineering-grade, and this is still true in 2024/2025.
There have been some attempts to add buoyancy physics to Blender (e.g., the "Ocean" modifier + custom scripts), but none provide engineering-quality hydrostatic/hydrodynamic simulation. You could theoretically write a Python add-on that applies approximate buoyancy forces using Blender's Python API, but this would be reinventing the wheel — and doing it worse than existing dedicated tools.
Commercial — Very Expensive
OrcaFlex by Orcina is the industry-standard tool for exactly your problem — floating structures with mooring lines and articulated connections in waves. It handles nonlinear buoyancy on inclined cylinders, cable dynamics with snap loads, pivot joints, and produces excellent 3D visualizations.
Cost: ~$15,000–$30,000/year for a commercial license. Far beyond brainstorming budget.
Why mention it: When you get to the naval architect stage, this is likely what they'll use or recommend. Your Chrono/Capytaine results can be validated against OrcaFlex. Also, OrcaFlex has a free 3-month trial that might be worth exploring for validation of one design.
MAP++ is Free
MAP++ (Mooring Analysis Program): NREL's quasi-static mooring analysis tool. Simpler than MoorDyn (no dynamics — just static catenary solutions) but useful for initial cable sizing. Python-callable. Free.
ProteusDS: Commercial tool by DSA (Dynamic Systems Analysis). Good for mooring and cable dynamics but expensive.
AQWA (ANSYS): Industry-standard BEM + time-domain solver with mooring. Extremely expensive (ANSYS license).
pip install capytaine moordyn — takes minutes.capytaine.mesh_cylinder() or import from Blender/FreeCAD.Your 45° inclined cylinders create complications that most tutorials don't cover:
Use a hybrid approach: Morison equation on the legs (handles variable submergence naturally) + panel method on the main platform body if needed. This is standard practice in offshore engineering for semi-submersibles.
A snap load (snatch load) occurs when a cable goes slack, the connected bodies separate freely, and then the cable suddenly goes taut — creating a very high impulsive tension. This is one of the most dangerous failure modes for your design.
| Tool | Software Cost | Learning Curve | Handles Your Full Design? | AI Coding Assist? | Best For |
|---|---|---|---|---|---|
| Project Chrono | $0 | Moderate (2–4 weeks) | ✅ Yes — joints, cables, waves, visualization | Good (PyChrono) | Complete seastead simulation |
| Capytaine + MoorDyn | $0 | Moderate (2–3 weeks base, more for joints) | ⚠️ Partial — joints require custom coding | Excellent (pure Python) | Hydrodynamics + cable analysis |
| WEC-Sim | ~$3,500–5,500/yr | Lower (1–2 weeks) | ✅ Yes | Moderate (MATLAB) | If you already have MATLAB |
| DualSPHysics | $0 | Steep (3–6 weeks) | ❌ No articulated joints | Limited (XML config) | Nonlinear wave impact validation |
| OpenFOAM | $0 | Very Steep (4–8 weeks) | ❌ No multibody / cables | Limited | High-fidelity CFD (later stage) |
| Blender | $0 | Low for modeling | ❌ Not engineering-grade physics | Good (Python API) | Geometry creation + visualization only |
conda create -n seastead python=3.10 conda activate seastead conda install -c conda-forge -c projectchrono pychrono pip install capytaine moordyn meshio numpy scipy matplotlib
Note: Check if HydroChrono is included in the conda pychrono package. If not, you may need to build from source.
git clone https://github.com/projectchrono/chrono.git
cd chrono
mkdir build && cd build
cmake .. -DENABLE_MODULE_PYTHON=ON \
-DENABLE_MODULE_IRRLICHT=ON \
-DENABLE_MODULE_HYDROCHRONO=ON
make -j$(nproc)
# Follow HydroChrono build instructions at:
# https://uwmadison-hydrochrono.github.io/
python -c "import pychrono; print('Chrono OK')"
python -c "import capytaine; print('Capytaine OK')"
python -c "import moordyn; print('MoorDyn OK')"
"""
Seastead simulation - Project Chrono + HydroChrono + MoorDyn
Step 1: Hydrodynamic preprocessing with Capytaine
Step 2: Time-domain simulation with Chrono
"""
# === STEP 1: BEM preprocessing with Capytaine ===
import capytaine as cpt
import numpy as np
# Create cylinder mesh for one leg (4 ft diameter, 24 ft long)
leg_radius = 4 * 0.3048 / 2 # convert to meters (0.6096 m)
leg_length = 24 * 0.3048 # convert to meters (7.3152 m)
# Create mesh, rotate 45 degrees
cylinder = cpt.FloatingBody(
mesh=cpt.mesh_horizontal_cylinder(
length=leg_length, radius=leg_radius,
center=(0, 0, -leg_length/2 * np.sin(np.pi/4)),
resolution=(20, 20, 20)
),
name="leg"
)
# ... set up dofs, run BEM solver, save results ...
# === STEP 2: Chrono time-domain simulation ===
import pychrono as chrono
import pychrono.irrlicht as chronoirr
# import hydrochrono # HydroChrono module
# Create Chrono system
system = chrono.ChSystemNSC()
system.Set_G_acc(chrono.ChVectorD(0, 0, -9.81))
# Create main platform body
platform = chrono.ChBodyEasyBox(
40*0.3048, 16*0.3048, 1.0, # dimensions in meters
500, # density (adjust for correct mass)
True, True # visualization, collision
)
platform.SetPos(chrono.ChVectorD(0, 0, 3.0)) # above waterline
system.Add(platform)
# Create 4 leg bodies
legs = []
for i, (dx, dy) in enumerate([(-1,-1), (-1,1), (1,-1), (1,1)]):
leg = chrono.ChBodyEasyCylinder(
leg_radius, leg_length,
300, # density (for correct buoyancy)
True, True
)
# Position and rotate to 45 degrees
# ... (calculate corner positions) ...
system.Add(leg)
legs.append(leg)
# Add revolute joint between leg and platform
joint = chrono.ChLinkRevolute()
joint.Initialize(platform, leg,
chrono.ChFrameD(corner_position, rotation))
system.Add(joint)
# Add MoorDyn cables
# ... (configure MoorDyn lines between leg bottoms) ...
# Add HydroChrono hydrodynamic forces
# ... (load BEM data, apply to each body) ...
# Add wave excitation
# ... (configure regular/irregular waves) ...
# Set up visualization
vis = chronoirr.ChVisualSystemIrrlicht()
vis.AttachSystem(system)
vis.Initialize()
# Simulation loop
while vis.Run():
system.DoStepDynamics(0.01) # 10ms timestep
vis.Render()
# Log cable tensions, detect snap loads
# ... (query MoorDyn forces) ...
This is a skeleton — Claude Code / Cursor.ai can fill in the details based on the HydroChrono documentation and examples.
Start with small waves and increase until failure. For each wave condition, run for at least 20+ wave periods to capture steady-state response.
| Sea State | Significant Wave Height (Hs) | Peak Period (Tp) | Description |
|---|---|---|---|
| 1 - Calm | 0.5 ft (0.15 m) | 3–5 s | Baseline — everything should be fine |
| 2 - Slight | 1.5 ft (0.5 m) | 4–6 s | Typical Caribbean fair weather |
| 3 - Moderate | 3 ft (1.0 m) | 5–8 s | Typical trade wind seas |
| 4 - Rough | 5 ft (1.5 m) | 6–9 s | Strong trade winds / approaching storm |
| 5 - Very Rough | 8 ft (2.5 m) | 7–10 s | Storm conditions — find cable slack onset |
| 6 - High | 12 ft (3.5 m) | 8–12 s | Severe storm — likely cable snap loads |
| 7 - Very High | 16+ ft (5+ m) | 10–14 s | Hurricane conditions — find ultimate failure |
Near Anguilla, typical trade wind seas are 3–5 ft. However, hurricane season (June–November) can bring swells of 10–20+ ft. For a seastead that can relocate slowly, the strategy might be:
| Tool | Search Terms / Links | What You'll See |
|---|---|---|
| Project Chrono |
"project chrono floating body wave" "hydrochrono simulation" "project chrono mooring" Project Chrono YouTube Channel |
Floating bodies in waves, vehicle dynamics, multibody systems. Marine examples are growing but fewer than other tools. Look for floating wind turbine demos. |
| Capytaine / BEM |
"capytaine boundary element wave" "NEMOH floating body" (predecessor) |
Mostly academic presentations. Capytaine itself doesn't produce 3D animations — it outputs hydrodynamic coefficients. Videos are of results plotted or post-processed. |
| WEC-Sim |
"WEC-Sim simulation waves" "WEC-Sim multibody" |
Good 3D animations of wave energy converters in waves. Articulated bodies, mooring lines visible. Closest visual match to what you want. |
| DualSPHysics |
"DualSPHysics floating structure waves" "DualSPHysics coastal engineering" DualSPHysics YouTube Channel |
Visually the most impressive — you see individual water particles splashing. Floating boxes and cylinders in wave tanks. Great for intuitive understanding of wave-structure interaction. |
| OpenFOAM |
"OpenFOAM floating body waves CFD" "OpenFOAM offshore structure" |
High-fidelity free surface visualizations. Pressure fields, velocity vectors. Very detailed but typically single rigid body. |
| MoorDyn | "MoorDyn mooring line simulation" | Mooring line dynamics — you'll see lines going slack and taut, which is exactly your cable analysis need. |
This is a significant advantage for the Python-based tools. Here's how to use them effectively:
All of these tools produce models, not reality. At the brainstorming stage, any of the recommended tools gives useful comparative information (Design A vs. Design B, effect of adding a cable, etc.). However:
Document prepared for seastead design brainstorming. Last updated: 2025.
Tools and capabilities described based on publicly available information as of early 2025.
All software recommendations are for the specific use case described (semi-submersible seastead with articulated legs and cables).