Seastead Simulation Software Analysis

Based on your requirements for high engineering accuracy, specific geometry (angled cylinders, cables), and the need to detect snap-loads in non-linear wave conditions, here is a comparative analysis of open-source software options compatible with your high-end hardware (Threadripper + A6000 GPU).

Executive Summary: The Top Contender

Detailed Software Comparison

In-Depth Analysis of Options

1. Project Chrono (The Recommended Path)

You mentioned trying Project Chrono but worrying about BEM. However, Chrono::FSI uses SPH (Smoothed Particle Hydrodynamics), not BEM. This is crucial for your design.

• Why it fits: Your legs are at 45 degrees. As the boat rolls, a leg might exit the water or slam back in. BEM cannot calculate the force of a cylinder slamming into water. SPH can. Furthermore, Chrono is built for multibody systems; defining a "cable" that goes slack and then snaps tight is native to Chrono, whereas in pure fluid solvers, you have to hack the physics to make it work.
• Hardware: Chrono::FSI supports GPU acceleration. Your NVIDIA A6000 will make SPH simulations significantly faster.
• AI Assistance: Chrono has Python bindings (pychrono). You can ask Claude/Cursor to "Write a PyChrono script that creates a floating box with 4 angled cylinders connected by tension-only elements."

2. DualSPHysics

This is a dedicated SPH solver. It is incredibly powerful for fluid dynamics.

• Pros: It handles the water physics slightly better than Chrono in some extreme cases (breaking waves, green water on deck). It is highly optimized for GPUs.
• Cons: It is primarily a fluid solver. While it has a "Floating Object" module, creating a complex tensegrity system (pivots + cables + specific tension limits) is more difficult than in Chrono. You might find yourself fighting the software to get the cable physics right.
• Verdict: Use this if Chrono proves not to be accurate enough for the water interaction, but be prepared for a steeper learning curve on the structural side.

3. Capytaine + MoorDyn

This is the standard for Wave Energy Converters (WEC).

• Pros: Very fast. Easy to script in Python. MoorDyn is excellent for calculating cable tension.
• Cons: It uses Linear Wave Theory (BEM). It assumes the waves are small and the body motions are small.
  Warning: For a seastead with 45-degree legs, if the boat heaves (bobs) significantly, the submerged volume of the legs changes non-linearly. Capytaine might underestimate the restoring force or fail to predict the "snap" load accurately because it smooths out the hydrodynamics.
• Verdict: Good for a "sanity check" or initial design, but likely insufficient for your specific goal of finding failure points in high waves.

4. WEC-Sim (MATLAB)

You asked about costs. WEC-Sim itself is free (open source on GitHub), but it requires MATLAB.

• Cost: A commercial license for MATLAB + Simulink + Simscape Multibody is expensive. For a single user in Anguilla, a perpetual license could cost $5,000 - $8,000 USD depending on the toolboxes needed. An annual license is cheaper (~$2,000/yr) but recurring.
• Verdict: Since you want open source and have the hardware to run C++/Python solvers, skip this. Chrono does what WEC-Sim does but without the MATLAB tax.

5. Blender

Is Blender accurate? No.

• Physics: Blender uses the "Bullet" physics engine. It is designed for video games, not engineering. It does not calculate hydrodynamic drag, added mass, or wave excitation forces correctly. It treats water as a visual mesh or a simple voxel fluid that pushes objects, but it won't tell you if a cable will snap at 5000 lbs of tension.
• Use Case: Use Blender after you have the data from Chrono. You can export the motion data from Chrono and import it into Blender to make a beautiful, cinematic video for your website.

Reusability: How hard is the next model?

Once you have a working script for your first design (let's call it seastead_v1.py), creating a new design is very easy.

Because you are using code (Python/C++), the geometry is defined by variables. To change the design, you simply change the numbers in the script:

# Example PyChrono pseudo-code
leg_length = 24.0  # Change to 30.0
leg_angle = 45.0   # Change to 30.0
cable_stiffness = 100000 # Change to 200000
platform_width = 40.0
    

Claude Code or Cursor can easily refactor your code to accept these parameters from a JSON file or a simple GUI, allowing you to run "Parameter Sweeps" (e.g., "Simulate leg angles from 30 to 60 degrees and plot max cable tension").

Final Recommendation Plan

1. Install Project Chrono: Follow the build instructions for the FSI module. Ensure it detects your CUDA GPU.
2. Start with PyChrono: Ask your AI assistant: "Create a PyChrono FSI simulation with a rigid box floating in a tank. Add 4 cylinders attached at angles. Use SPH for the fluid."
3. Add Cables: Once the floating box works, add the ChLinkTension or similar cable elements to connect the leg bottoms.
4. Visualize: Use the built-in Chrono visualization or export to CSV and plot in Python/Matplotlib for the engineering data (Tension vs Time).