Seastead Simulation Tool Analysis

Based on your unique seastead design features (40x16ft floating platform, 45-degree multi-submerging pivoting legs, structural cable meshes, and the need to test extreme wave snatch loads), here is an engineering-level evaluation of the open-source landscape.

The "Non-Linear" Challenge: You correctly identified that linear assumption models (BEM) break down when a leg goes from 1/3 submerged to completely submerged or exits the water. Linear models assume the waterplane area stays roughly constant. For extreme plunging waves, we need tools that calculate fluid forces on the actual geometry at that exact moment (non-linear Froude-Krylov forces or full CFD/SPH).

1. DualSPHysics (Coupled with Project Chrono & MoorDyn) - Highly Recommended

DualSPHysics uses Smoothed Particle Hydrodynamics (SPH). Instead of a mesh, it simulates water as millions of physics particles. Crucially, DualSPHysics has natively integrated Project Chrono (for multibody pivots/hinges) and MoorDyn (for cables/snap loads).

Pros: PERFECT for non-linear waves, splashing, and elements entering/exiting the water. Uses your Linux GPU masterfully. You can track exact snap loads on cables. Setup is largely done visually via FreeCAD.
Cons: SPH is computationally expensive. Simulating 60 seconds of real-time waves might take overnight to compute. AI tools (Cursor/Claude) are slightly less helpful here because setup is mostly XML/FreeCAD rather than raw Python code.
Accuracy: High. It captures real-world splashing, overtopping, and highly non-linear drag.
Time to Setup: 2–4 weeks. Learning the GUI and XML structure takes time, but no advanced C++ is required.

DualSPHysics Wave energy converter with MoorDyn & Chrono (Notice the cables and multibody hinges)
DualSPHysics Extreme Wave interactions

2. Project Chrono (PyChrono + HydroChrono) - Best for AI (Cursor/Claude)

Project Chrono is a top-tier multibody dynamics engine. You can code the entire seastead in Python using PyChrono. You can create the platform, attach legs via hinge/pivot nodes, attach cables via Chrono::FEA or spring-dampers (to log snatch loads), and use HydroChrono to apply wave forces.

Pros: Massive AI synergy. Cursor.ai is incredible at generating Python/PyChrono scripts. Incredibly accurate for the cable dynamics and pivot points. Much faster to simulate than DualSPHysics (runs near real-time).
Cons: HydroChrono uses BEM (linear) data by default. However, you can bypass this in Chrono by scripting a custom buoyancy calculation script that checks the submerged volume of your 3D cylinders at every timestep. This is achievable with Claude/Cursor.
Accuracy: Perfect for structural/mechanical (hinges/cables). Fair to Good for hydrodynamics (depending on how you code the buoyancy check).
Time to Setup: 1-3 weeks. Cursor will write the boilerplate, but debugging Python multibody math takes patience.

WEC Simulation using Project Chrono (Shows complex joint/wave behavior)

3. Capytaine + MoorDyn (Raw Python) - Requires a missing link

Capytaine computes hydrodynamic coefficients (linear BEM). MoorDyn computes cable snap loads. The problem: Neither of these tools solves "multibody temporal physics" (i.e., hinges moving over time). If you just stitch them together in Python, you'd have to write your own physics solver to handle the pivoting legs acting on the main hull. (Note: WEC-Sim does this missing part, but see below).

Verdict: Do not use raw Capytaine + MoorDyn independently for this design. You need a multibody framework. PyChrono is the right way to hold MoorDyn + Hydrodynamics together.

4. Blender Physics - For Visualization ONLY

You were informed correctly: Blender's native physics are absolutely not for marine engineering. Blender uses the "Bullet" physics engine, which has zero understanding of buoyancy, fluid dynamics, wave particles, or precise snatch loads on elastic mooring cables.

The Right Way to Use Blender: Use PyChrono or DualSPHysics to do the actual mathematics. Have your Python scripts output a .csv or a `.bvh` file of the positional data. Write a simple Python script in Blender (Claude can do this in seconds) to read that text file and animate your 3D models. Then let Blender render beautiful ocean water around your pre-calculated animation to show investors/colleagues.

5. WEC-Sim & MoorDyn (MATLAB Cost Barrier)

WEC-Sim is the standard for exactly your type of design (multibody hinges, floats, cables in waves). Unfortunately, it relies entirely on MATLAB toolboxes.

Estimated Cost for Anguilla (Commercial/Non-Student):
MATLAB Base (~$2,350) + Simulink (~$3,500) + Simscape (~$4,000) = ~$9,850+ USD, plus annual maintenance.
Verdict: Far too expensive for open-source brainstorming. Skip it. (Keep an eye on the "OpenWEC" project in the future, which is aiming to port WEC-Sim to Python, but it isn't ready yet).

Summary Comparison

Software Approach	Setup Time (w/ AI)	Multibody/Cables	Non-Linear Waves (Leg Submersion)	Overall Recommendation
PyChrono + Custom Buoyancy	1 - 3 Weeks	Excellent (Native)	Moderate (Needs custom script)	1st Choice for AI. Best if you want to use Cursor.ai to code the physics logic rapidly.
DualSPHysics (GPU based)	2 - 4 Weeks	Excellent (Via Chrono)	Perfect (Full Particle fluid)	1st Choice for Physics Accuracy. Best if you want realistic splashing and large pitch/roll events without writing complex physics solvers.
Capytaine + MoorDyn	N/A	Poor (No solver)	Poor (Linear BEM only)	Avoid as a standalone combo. Needs PyChrono.
Blender Physics	1 Week	Visual Only	Visual Only	Use ONLY to render the final data output from PyChrono.

Recommended Workflow for Your Situation

Start with PyChrono: Open Cursor.ai. Tell Claude: "I want to write a PyChrono script. I need a central rigid body platform, and 4 cylinder legs connected via hinge joints at 45 degree angles. Let's add simple spring-dampers to simulate the cables holding the legs. I will define a custom force function at each timestep to calculate buoyancy based on how deep the legs plunge."
Tune Cable Snap Loads: Because you are writing Python, you can simply tell your script to print a massive warning if the tension in any cable drops to 0 (goes slack) and then instantly spikes upward (snap/snatch load).
Advance to DualSPHysics (Optional): Once you have a python model that makes sense dynamically, load your STL files into FreeCAD and use the DualSPHysics plugin utilizing your Linux GPU. This will drop your seastead into a real virtual wave basin to catch complex wave phenomenons that simple math misses.
Visualize: Take the X,Y,Z rotation data from your successful simulation and pipe it into Blender for an investor-ready video.