Open-source and free tools for simulating a tensegrity semi-submersible seastead with articulated legs, cables, and nonlinear wave interaction
Your seastead is an unusual structure: a semi-submersible platform with four 4-ft-diameter cylindrical legs at 45° angles, connected by cables in a tensegrity arrangement, with articulated pivot points allowing relative motion between leg pairs and the hull. You need to simulate this in waves with enough fidelity to capture:
These requirements immediately rule out pure BEM (Boundary Element Method) approaches as your primary hydrodynamic solver. BEM assumes small motions around a mean position and linear free-surface conditions. Your legs going from ⅓ to nearly fully submerged violates these assumptions fundamentally. You were right to suspect this.
DualSPHysics is a GPU-accelerated Smoothed Particle Hydrodynamics (SPH) solver that handles fully nonlinear wave-structure interaction with no linear assumptions. Your NVIDIA A6000 (48 GB VRAM, 10,752 CUDA cores) is an exceptional match. Combined with MoorDyn for cable dynamics, this gives you the highest-fidelity simulation of your specific design. It directly produces 3D visualizations via ParaView. Estimated time to first simulation with Claude Code assistance: 2–3 weeks.
OpenFOAM using Volume of Fluid (VOF) for free surface tracking gives you CFD-grade accuracy with full Navier-Stokes resolution. It can handle your nonlinear geometry changes, viscous effects, and wave breaking. It is more computationally expensive than SPH for this application but gives publication-quality results. Your 64-core Threadripper can run large meshes with adaptive mesh refinement. Estimated time: 3–5 weeks.
Below is a detailed comparison of every viable option, with estimated setup times, accuracy assessments, video references, reusability for new designs, and specific notes about your seastead geometry.
Leg submergence varies from ~33% to ~90%. Buoyancy forces change nonlinearly as circular cylinders at 45° enter/exit water.
Cables can go slack then snap taut. Need to detect peak tensions after re-tensioning. Linear mooring models miss this entirely.
Front legs pivot as a pair, back legs mirror. Changes geometry, thrust direction, and wave interaction in real time.
4-ft diameter cylinders at Keulegan-Carpenter numbers where drag dominates over diffraction. Morison equation applicable but needs Cd calibration.
Testing from calm seas to survival conditions. Steep waves = nonlinear free surface. Need at least 2nd-order wave theory, ideally fully nonlinear.
Must produce clear 3D animations showing cable tensions, leg positions, and failure modes. ParaView or similar post-processing.
Boundary Element Methods (used by Capytaine, WAMIT, NEMOH, Ansys AQWA, and as the hydrodynamic pre-processor for WEC-Sim and Project Chrono's hydrodynamics module) solve the linearized potential flow problem. This means:
For your design, BEM-based tools will give you qualitatively wrong answers. They'll underpredict motion amplitude, miss the damping from viscous drag on legs, completely miss cable snap loads, and won't capture the nonlinear restoring forces from variable submergence. You are correct that you need something better. The time you'd spend setting up BEM would be largely wasted for your specific application.
The one exception: you could use a Morison-equation based time-domain solver (which is NOT BEM) to get reasonable engineering estimates quickly. More on this below.
DualSPHysics is an open-source Smoothed Particle Hydrodynamics (SPH) solver, heavily optimized for GPU computation. It simulates fluids as particles rather than on a mesh. This means there is NO linearization of the free surface — waves form naturally, break naturally, and interact with bodies in a fully nonlinear manner. Bodies can have arbitrary geometry, move freely, be connected by joints and springs, and undergo large motions including variable submergence.
It was originally developed for coastal engineering (wave interaction with breakwaters, harbors, etc.) but has been extensively extended for floating body dynamics including mooring systems via its coupling with MoorDyn (lumped-mass mooring dynamics library) and Project Chrono (for multibody articulated mechanisms).
DualSPHysics floating or DualSPHysics mooring for many more examples.Particle resolution: For your 4-ft diameter legs, you want at least 8–10 particles across the diameter for good force resolution. That means a particle spacing (dp) of about 0.4–0.5 ft (12–15 cm). For a wave tank of ~100m × 60m × 10m deep, that's approximately 5–15 million particles — well within your A6000's capability.
Simulation speed: On an A6000, with ~10M particles, expect roughly 10–50× slower than real time (i.e., 1 second of real time takes 10–50 seconds to compute). A 60-second simulation would take 10–50 minutes. A 5-minute simulation would take 1–4 hours. This is very reasonable for design iteration.
Website: https://dual.sphysics.org/
OpenFOAM (Open Field Operation and Manipulation) is the industry-standard open-source CFD toolkit. For wave-structure interaction, it uses the Volume of Fluid (VOF) method to track the free surface on a mesh. The solver interFoam (or interIsoFoam for sharper interfaces) solves the full incompressible Navier-Stokes equations with a two-phase (air-water) model.
Wave generation is handled by libraries like waves2Foam or olaFlow (also known as IHFOAM), which can generate regular waves, irregular waves (JONSWAP, Pierson-Moskowitz spectra), and even focused wave groups for extreme event testing.
For floating body motion, OpenFOAM uses sixDoFRigidBodyMotion or overset (chimera) mesh approaches. For multiple articulated bodies with cables, you'd couple with MoorDyn (which has an OpenFOAM coupling library) or use a custom implementation.
blockMesh/snappyHexMesh. This is where it gets harder than DualSPHysics — meshing complex geometries is OpenFOAM's notorious pain point. Claude Code can help generate the mesh dictionaries.
rigidBodyMotion library which supports joints, (c) custom coded.
OpenFOAM floating body waves or interFoam waves2Foam floating.Website: https://www.openfoam.com/ (ESI) or https://openfoam.org/ (Foundation)
You've already tried Project Chrono. The key distinction is between Chrono::Hydro (which uses BEM data from Capytaine/WAMIT — and which you correctly identified as inadequate) and Chrono::FSI (Fluid-Solid Interaction, which uses SPH). Chrono::FSI is actually an SPH solver built directly into the Chrono multibody framework.
The advantage of Chrono::FSI over DualSPHysics is that Chrono's multibody dynamics engine is arguably the best open-source one available — it handles joints, constraints, contacts, cables, and articulated mechanisms natively. The disadvantage is that Chrono::FSI's SPH solver is less mature and less optimized than DualSPHysics for wave-structure interaction problems specifically.
Here's the crucial insight: DualSPHysics uses Project Chrono as its multibody engine when you enable the coupling. So by using DualSPHysics, you get DualSPHysics's superior SPH solver AND Chrono's superior multibody dynamics. This is why DualSPHysics is the top pick — it's effectively the best of both worlds.
Using Chrono::FSI directly would mean using Chrono's less-optimized SPH solver but with tighter integration into the multibody framework. For most users, the DualSPHysics+Chrono coupling is the better path.
Project Chrono FSI SPH for various demonstrations.Website: https://projectchrono.org/
Proteus is a computational mechanics toolkit developed by the U.S. Army Corps of Engineers (ERDC) for simulating fluid-structure interaction problems, particularly in coastal and hydraulic engineering. It uses finite element methods with level set free surface tracking and can solve Reynolds-Averaged Navier-Stokes (RANS) equations.
It includes the chrono module for coupling with Project Chrono for rigid body dynamics and can handle moored floating structures. It has been used for some offshore and wave energy converter simulations.
Proteus is Python-based, which is nice for Claude Code integration, but the community is very small and documentation is limited. For your purposes, OpenFOAM gives similar or better accuracy with a much larger support community. Not recommended as a primary choice.
GitHub: https://github.com/erdc/proteus
Capytaine is a Python-based BEM solver (fork of NEMOH) for computing linear hydrodynamic coefficients. MoorDyn handles mooring line dynamics. Together, they can simulate floating bodies with mooring systems in the frequency or time domain.
As discussed in Section 2, BEM is fundamentally inadequate for your design. However, there IS a potential use case:
You could use Capytaine to get rough hydrodynamic coefficients for a simplified version of your platform (ignoring leg articulation) and MoorDyn for cable dynamics, running time-domain simulations in Python. This would take only 3–5 days to set up and would give you a rough (but quantitatively unreliable) sense of motion responses. The cable tension results from MoorDyn would be more useful than the motion predictions.
Think of it as a quick screening tool: if a design looks terrible even with linearized hydrodynamics, it's definitely terrible. But if it looks okay, you still need to validate with a nonlinear solver.
Capytaine: https://github.com/capytaine/capytaine
WEC-Sim (Wave Energy Converter Simulator) was developed by NREL and Sandia National Laboratories. It's a time-domain solver that uses BEM hydrodynamic data (from Capytaine, NEMOH, or WAMIT) and Simulink/Simscape Multibody for the mechanical system. It can handle articulated multibody systems with constraints, moorings via MoorDyn, and nonlinear hydrostatic restoring forces (as a correction to the linear BEM).
You correctly identified the cost issue. Here's the breakdown:
This is NOT open source and should not be on your list. The ~$1,580–$4,850/year cost is unjustified when DualSPHysics gives better accuracy for free. Additionally, WEC-Sim uses BEM hydrodynamic data as its foundation, so it has the same fundamental accuracy limitations as Capytaine for your design, despite having better multibody dynamics on top.
WEC-Sim CAN add nonlinear Froude-Krylov forces and nonlinear hydrostatic restoring, which partially addresses the variable submergence issue. But it still uses linear radiation/diffraction, which is wrong for your slender cylinders.
Furthermore, there is now an effort called WEC-Sim in Python (WecOptTool/WECOPTTOOL) but it doesn't yet replicate full WEC-Sim functionality.
Verdict: Your money and time are better spent on DualSPHysics or OpenFOAM.
Website: https://wec-sim.github.io/WEC-Sim/
OrcaFlex (by Orcina) is the industry standard for mooring analysis, cable dynamics, and floating body simulation. It uses Morison equation for slender members, BEM data for large bodies, and has excellent cable/mooring dynamics. It costs ~$15,000–$30,000+/year. Not an option.
OpenFAST is the open-source aero-hydro-servo-elastic simulation tool for wind turbines. Its HydroDyn module uses Morison equation for slender members AND potential flow for large bodies. Its MoorDyn module (same MoorDyn we keep mentioning) handles cables. SubDyn handles substructure dynamics.
This is actually interesting for your application because HydroDyn's Morison equation formulation is exactly right for your slender cylindrical legs. You would:
The catch: OpenFAST is designed for wind turbines and floating wind platforms. Adapting it for a seastead requires disabling the aerodynamic modules and repurposing the structural framework. It's doable but awkward.
OpenFAST has been used for semi-submersible floating wind platforms, which share some structural similarities with your seastead. The Morison-equation approach in HydroDyn can handle variable submergence if you use the "strip theory" formulation that integrates forces along the instantaneous wetted length of each member.
Website: https://github.com/OpenFAST/openfast
A quasi-static mooring analysis library. Useful for initial cable sizing but doesn't capture dynamic snap loads. MoorDyn is better for your needs.
Your information is correct: Blender's built-in physics simulations are NOT engineering-accurate and this has not fundamentally changed. Here's the detailed breakdown:
In theory, you could write Python scripts in Blender that:
But at that point, you're writing your own hydrodynamics engine inside Blender and only using Blender as a renderer. You'd be better off doing the simulation in Python/DualSPHysics/OpenFOAM and using ParaView or Blender only for final rendering of the results.
Use Blender as a visualization/rendering tool for results computed elsewhere. Export body positions and cable configurations from your DualSPHysics or OpenFOAM simulation as time series, import them into Blender, and render beautiful photorealistic animations with ocean backgrounds. This produces the most compelling videos for your website. There are Blender add-ons for importing VTK data and for ocean surface generation.
REEF3D is an open-source CFD solver specifically designed for marine applications. It uses a level set method for free surface tracking and has been used for wave-structure interaction problems. It might be worth investigating as an alternative to OpenFOAM — it's simpler to set up for wave problems. However, it has a much smaller community and limited multibody capability.
Website: https://reef3d.wordpress.com/
General-purpose finite element libraries. Could theoretically be used to build a custom hydrodynamic solver, but this would be a months-long research project, not a practical engineering tool.
Open-source structural FEA platform. Excellent for structural analysis of your legs under load, but not a hydrodynamic simulator. Could be useful later for detailed stress analysis of leg-platform connections and cable attachment points.
Structural earthquake engineering simulator. Has some hydrodynamic loading capabilities (Morison equation) but is primarily for structures, not fluid dynamics. Not recommended.
Commercial software by DSA (Dynamic Systems Analysis). Good for mooring and cable dynamics but NOT free. Costs significant money. Skip.
QBlade is an open-source wind turbine design tool that recently added floating platform simulation with Morison equation hydrodynamics and MoorDyn mooring. Similar to OpenFAST but with a better GUI. Worth a look as a quick-setup alternative.
Website: https://qblade.org/
An open-source nonlinear wave solver. Generates very accurate nonlinear wave fields but doesn't include structure interaction. Could be used as a wave input generator for other tools.
Similar to HOS-Ocean — a nonlinear potential flow wave solver. Generates wave kinematics that can feed into Morison equation calculations. No structural interaction.
A surprisingly viable option for quick engineering estimates: write a Python time-domain simulator that uses Morison equation for hydrodynamic forces on each leg, instantaneous-waterplane hydrostatics for buoyancy, MoorDyn (via its C library or Python wrapper) for cables, and a simple rigid body dynamics integrator. Claude Code could write this in 3–5 days. Accuracy would be engineering-estimate level (not CFD-grade) but it would capture the key physics: nonlinear buoyancy, drag-dominated loading, cable snap loads, and articulated motion.
| Tool | Method | Free? | Accuracy (Your Design) |
Nonlinear Hydrostatics |
Cable Snap Loads |
Articulated Joints |
GPU Usage |
CPU Usage |
Visualization | Setup Time (w/ Claude) |
New Design Variant |
Community Size |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| DualSPHysics + MoorDyn + Chrono | SPH (particle) | ✅ Yes | Some | 2–3 weeks | 1–3 days | |||||||
| OpenFOAM + olaFlow + MoorDyn | VOF (mesh CFD) | ✅ Yes | 3–5 weeks | 2–5 days | ||||||||
| Chrono::FSI | SPH (particle) | ✅ Yes | Some | 2–4 weeks | 1–3 days | |||||||
| OpenFAST (HydroDyn + MoorDyn) | Morison + BEM hybrid | ✅ Yes | 2–4 weeks | 1–2 days | ||||||||
| Custom Python + Morison + MoorDyn | Semi-empirical | ✅ Yes | 3–7 days | 0.5–1 day | N/A (custom) | |||||||
| Capytaine + MoorDyn | BEM + time domain | ✅ Yes | 3–5 days | 0.5–1 day | ||||||||
| WEC-Sim | BEM + Simulink | ❌ ~$1,500–$5,000/yr | 1–2 weeks | 1–2 days | ||||||||
| REEF3D | Level set CFD | ✅ Yes | 3–5 weeks | 2–4 days | ||||||||
| QBlade | Morison + BEM | ✅ Yes (CE edition) | 1–2 weeks | 1–2 days | ||||||||
| Blender | FLIP (VFX) | ✅ Yes | N/A | N/A |
This is a critical question since you want to iterate through multiple tensegrity configurations.
Reusability: EXCELLENT (1–3 days for new design)
The DualSPHysics workflow is:
For a new seastead design with different cylinder sizes and configuration, you modify the XML file (or have Claude Code modify it) to change dimensions, positions, joint locations, and cable attachments. Everything else (wave conditions, solver settings, post-processing scripts) stays the same.
With Claude Code, you could build a parametric Python script that generates DualSPHysics XML input files from high-level design parameters (leg length, leg angle, leg diameter, platform size, cable configuration). Then testing a new design is literally changing a few numbers and running the script. This is the ideal workflow for design exploration.
Reusability: MODERATE (2–5 days for new design)
The bottleneck is mesh generation. Every new geometry requires re-meshing with snappyHexMesh or cfMesh, which often requires manual tuning of mesh parameters to get good quality. For similar designs (same basic shape, different proportions), you can parameterize the mesh generation scripts, but for fundamentally different configurations, expect 2–5 days of mesh work.
Reusability: BEST (0.5–1 day for new design)
Since the geometry is just defined as lists of cylinder positions, lengths, and angles in Python, changing the design is trivial. This is the fastest way to screen many designs quickly, even if accuracy is lower.
Build a custom Python + Morison equation + MoorDyn simulator
Set up DualSPHysics + MoorDyn + Chrono
Run selected cases in OpenFOAM for comparison/validation
Use Blender for final visualization
Since you won't have model-test data for your specific design, validation relies on:
| Software | Search Terms for YouTube | What You'll See |
|---|---|---|
| DualSPHysics | DualSPHysics floating body mooring, DualSPHysics wave structure |
Particle-based simulations with floating bodies, mooring lines, wave tanks. Colored particles showing pressure/velocity. |
| OpenFOAM | OpenFOAM floating body waves interFoam, olaFlow floating |
Mesh-based VOF simulations with sharp free surface, floating structures, wave tanks. |
| Project Chrono | Project Chrono FSI SPH, PyChrono fluid |
SPH particles interacting with rigid bodies, multibody mechanisms in fluid. |
| OpenFAST | OpenFAST floating wind turbine, HydroDyn MoorDyn |
Floating wind platform simulations with mooring lines (less visual, more time-series plots). |
| QBlade | QBlade floating offshore |
3D visualization of floating wind turbine with mooring lines and wave interaction. |
| REEF3D | REEF3D wave structure |
Level-set CFD of waves interacting with coastal and offshore structures. |
Note: Specific YouTube URLs may become unavailable over time. The search terms above should always find relevant current examples.
| Quick screening | Custom Python + Morison + MoorDyn (3–7 days, medium accuracy) |
| Primary simulation | DualSPHysics + Chrono + MoorDyn on A6000 GPU (2–3 weeks, high accuracy) |
| Validation | OpenFOAM + olaFlow + MoorDyn on 64-core Threadripper (3–5 weeks, highest accuracy) |
| Visualization | ParaView for analysis; Blender for presentation-quality renders |
| Cable analysis | MoorDyn throughout (consistent cable dynamics across all tools) |
This approach maximizes the use of your exceptional hardware (A6000 GPU + 64-core Threadripper + 750 GB RAM), provides engineering-grade accuracy without linear assumptions, supports your articulated tensegrity design, captures cable snap loads, produces compelling visualizations, and allows rapid iteration through design variants with Claude Code assistance.
The key insight is that MoorDyn appears in every recommended tool — it's the standard for cable/mooring dynamics and works across all platforms. Learn it once, use it everywhere.
Your A6000 GPU is particularly well-suited for DualSPHysics, which is why it edges out OpenFOAM as the primary recommendation despite OpenFOAM's arguably higher theoretical accuracy ceiling. In practice, the faster iteration time with DualSPHysics on GPU will let you explore more designs and conditions, which is more valuable at your current design stage than squeezing the last 5% of accuracy from any single simulation.
| Hardware | Best Used By | Utilization |
|---|---|---|
| NVIDIA A6000 (48 GB VRAM, 10,752 CUDA cores) | DualSPHysics, Chrono::FSI | SPH with 10–50M particles. Your A6000 is one of the best possible GPUs for this workload. ~$4,500 GPU being used to its potential. |
| AMD Threadripper 64-core | OpenFOAM (MPI parallelism) | CFD meshes of 10–50M cells. Domain decomposition across 64 cores. Also good for DualSPHysics GenCase pre-processing and ParaView post-processing. |
| 750 GB RAM | OpenFOAM (large meshes), ParaView (large datasets) | Allows very large mesh simulations without swapping. Most simulations will use 50–200 GB. You have ample headroom. |
Document prepared for seastead design simulation planning.
Hardware: NVIDIA A6000 + AMD Threadripper 64-core + 750 GB RAM on Linux.
All recommended primary tools are open-source and free.
Last updated: 2025