```html Seastead Wave Simulation — Open Source Software Comparison
Seastead Engineering

Open-Source Wave Simulation for Small-Waterplane Seasteads

A comprehensive comparison of free simulation tools for nonlinear seakeeping analysis of spar-type floating platforms with large draft changes.

Critical Design Consideration

Why Linear Methods Fall Short for Your Design

Your seastead's legs transition from 50% submerged to nearly 100% submerged in extreme seas. This changes everything about the applicable simulation methods.

Boundary Element Method (BEM) solvers like Capytaine, NEMOH, and WAMIT linearize the problem around the mean waterline. They assume the body oscillates with small amplitude around its equilibrium position — the wetted surface area doesn't change significantly. Your seastead violates this assumption dramatically. When a 19-foot leg goes from 50% to ~100% submerged, the waterplane area, buoyancy force, and hydrodynamic coefficients all change nonlinearly. A BEM solver will incorrectly predict heave restoring forces, damping, and motion response in the exact conditions you care about most: when waves get big enough to be dangerous.
What you need is a fully nonlinear method that recalculates hydrodynamic forces at every time step based on the actual instantaneous wetted surface. The two practical approaches for this are SPH (Smoothed Particle Hydrodynamics) and CFD (Computational Fluid Dynamics). Both avoid the linear assumption entirely by solving the full Navier-Stokes equations (or a close approximation). The trade-off is computational cost: these methods require far more computing power than BEM. Fortunately, you have a powerful GPU.
Top Recommendation

DualSPHysics + Project Chrono Coupling

For your specific combination of needs — fully nonlinear hydrodynamics, GPU acceleration, floating rigid body dynamics, visualization, and open-source licensing — the DualSPHysics solver coupled with Project Chrono for rigid body dynamics is the strongest single option. DualSPHysics is a purpose-built, GPU-accelerated SPH code that has been extensively validated for free-surface flows with floating bodies. It natively handles large draft changes, wave breaking, and nonlinear wave-structure interaction. The Chrono coupling provides robust rigid body dynamics (6-DOF motion) including your truss frame, living quarters mass distribution, and the three NACA-foil legs. Output can be visualized in ParaView for high-quality video production. Setup time with Claude Code assistance: approximately 2–3 weeks to first simulation.

Side-by-Side

Feature Comparison Matrix

Software Method Nonlinear? GPU? Floating Bodies Python API Visualization Setup Time * Fit for Your Needs
DualSPHysics SPH Fully Native CUDA Yes + Chrono Partial ParaView 2–3 weeks Excellent
Chrono::FSI-SPH SPH Fully Yes (CUDA) Built-in 6-DOF PyChrono IRRLICHT / VSG 2–4 weeks Excellent
OpenFOAM (interDyMFoam) CFD (FVM) Fully No (CPU) Yes (6-DOF) PyFOAM ParaView 4–6 weeks Good
Reef3D CFD (FVM) Fully No (CPU/OpenMP) Yes No ParaView 4–6 weeks Good
SPlisHSPlasH SPH / PBF Fully Yes (CUDA) Rigid coupling Python bindings imgui / Partio 3–5 weeks Moderate
Capytaine + MoorDyn BEM Linear only N/A Yes Native Python Matplotlib / VTK 1–2 weeks Limited
Project Chrono (BEM) BEM + multibody Linear hydro N/A Yes PyChrono IRRLICHT / VSG 2–3 weeks Limited
WEC-Sim + MoorDyn BEM + Simulink Linear hydro N/A Yes MATLAB only MATLAB plots 3–4 weeks + cost Poor fit
Blender (MantaFlow) FLIP / SPH Visual only Partial Not validated Python API EEVEE / Cycles 1–2 weeks Not engineering

* Setup time estimates assume Claude Code / Cursor.ai assistance, working ~4 hrs/day, starting from a capable Linux or Windows machine with a good GPU. "First simulation" means a simplified version of your seastead running in regular waves with visualization.

Deep Dives

Detailed Software Analysis

DualSPHysics

dual.sphysics.org · GitHub

DualSPHysics is a GPU-accelerated SPH solver developed over 15+ years by the University of Vigo and University of Manchester. It was specifically designed for free-surface flows in coastal and offshore engineering. It has been validated against extensive experimental data for wave-structure interaction, floating bodies, and wave impact forces.

How it works for your seastead: You model the three NACA-foil legs and the triangular frame as a rigid body (or multiple rigid bodies coupled via Chrono). The water is represented by millions of SPH particles. At each time step, the solver computes pressure and velocity at every particle, finds the intersection of the body surface with the fluid, and computes hydrodynamic forces (buoyancy, drag, added mass, slamming) without any linearization. When a leg goes from 50% to 100% submerged, the solver simply sees more particles pushing on it — no assumptions violated.

Chrono coupling: DualSPHysics has an official coupling with Project Chrono for multi-body dynamics. This handles your 6-DOF rigid body motion (heave, surge, sway, roll, pitch, yaw) and could later support the stabilizer fins as separate bodies with actuated joints. The coupling is mature and has been used in published research on floating offshore platforms.

Wave generation: Built-in paddle-type and relaxation-zone wave generation for regular, irregular (spectral), and focused waves. You can ramp from calm to Sea State 6 to find where things break.

GPU usage: The CUDA implementation is highly optimized. A modern GPU (RTX 3080+) can handle 5–10 million particles at reasonable wall-clock times. For your 80×40 ft seastead in 3–4 m waves, you'd likely need 3–8 million particles depending on resolution.

Acceleration tracking: You can instrument any point on the rigid body to output position, velocity, and acceleration time histories. This directly answers your question about accelerations at different locations (e.g., living quarters vs. front deck).

Strengths

  • Fully nonlinear — no linear hydro assumptions
  • Native CUDA GPU acceleration — fast
  • Chrono coupling for rigid body dynamics
  • Extensive marine/offshore validation
  • Built-in wave generation (regular, irregular, focused)
  • Active community, good documentation
  • ParaView output = high-quality visualization
  • Free for any use (BSD-like license)

Limitations

  • Python API exists but is not as polished as PyChrono
  • Input files are XML-based (verbose but Claude Code can generate)
  • Resolution tied to particle spacing — need convergence studies
  • Long simulation times for irregular seas (hours to days of GPU time)
  • Post-processing requires ParaView or custom scripts
  • Not a turnkey product — needs engineering judgment
The strongest match for your needs. Fully nonlinear, GPU-accelerated, validated for floating bodies, and open-source. The Chrono coupling handles your rigid body dynamics. Setup is moderate effort but very feasible with Claude Code assistance generating XML input files and post-processing scripts.

Project Chrono — FSI-SPH Module

projectchrono.org · GitHub

Clarification on BEM vs. SPH in Chrono: Project Chrono has two separate hydrodynamics approaches. The "offshore" module can import BEM coefficients from Capytaine/NEMOH for linear hydrostatics and radiation/diffraction — this is the BEM path. But Chrono::FSI (also called FSI-SPH) is an entirely separate module that uses Smoothed Particle Hydrodynamics to model the fluid directly. When you use FSI-SPH, Chrono is NOT using BEM. It is solving the full nonlinear SPH equations at every time step.

The FSI-SPH module is GPU-accelerated (CUDA) and handles the coupled fluid-rigid body problem natively. You define your seastead as a Chrono rigid body (with mass, inertia, and geometry), and the SPH solver computes forces on it from the surrounding fluid particles.

Advantages over DualSPHysics standalone: Since everything is within Chrono, you get seamless access to Chrono's powerful multibody dynamics. If you later want to add the stabilizer fins as actuated bodies, mooring lines, or flexible structures, it's all in one framework. PyChrono gives you Python control over the entire simulation.

Caveats: The FSI-SPH module is less mature and less validated for marine applications than DualSPHysics. Documentation is thinner. The SPH formulation may not include all the numerical tricks (boundary conditions, density filtering) that DualSPHysics has refined over 15 years. However, it is actively developed and improving rapidly.

Strengths

  • Fully nonlinear SPH — no BEM assumptions
  • GPU-accelerated (CUDA)
  • Excellent Python API (PyChrono)
  • Full multibody dynamics in one framework
  • Easy to add stabilizers, moorings, joints later
  • Built-in visualization (IRRLICHT, VSG)
  • Active research group at UW-Madison

Limitations

  • FSI-SPH module less mature than DualSPHysics
  • Fewer published marine validation cases
  • Documentation for FSI-SPH specifically is sparse
  • May need more debugging to get running
  • SPH quality/resolution may lag behind DualSPHysics
Excellent choice, especially if you value Python integration and the ability to easily extend the simulation later (stabilizers, moorings, etc.). Less mature marine track record than DualSPHysics, but the unified framework is a significant architectural advantage. Consider running both and cross-validating.

OpenFOAM (interDyMFoam / overInterDyMFoam)

openfoam.org · ESI-OpenFOAM

OpenFOAM is the gold standard of open-source CFD. It uses the Finite Volume Method on an Eulerian mesh to solve the Navier-Stokes equations. The interDyMFoam solver handles two-phase (air/water) flow with a moving rigid body and dynamic mesh adaptation. overInterDyMFoam adds overset (chimera) mesh capability, which is ideal for large-amplitude body motions like your seastead pitching and heaving in big waves.

Accuracy: OpenFOAM has the highest potential accuracy of any tool on this list. It resolves boundary layers, captures viscous effects, and can predict drag, lift, and slamming forces with engineering precision. It is widely validated across industries.

The catch: It is CPU-only (no GPU acceleration in the main distributions). A simulation that takes DualSPHysics 4 hours on your GPU might take OpenFOAM 2–4 days on a good CPU. For long-duration irregular sea simulations, this becomes prohibitive. Additionally, mesh generation (snappyHexMesh or cfMesh) for your NACA-foil legs adds a setup step that SPH methods avoid entirely.

olaFlow / ihFoam: These are OpenFOAM-based solvers specifically for coastal engineering with built-in wave generation and active wave absorption. They can save you significant setup time compared to rolling your own wave boundary conditions.

Strengths

  • Highest accuracy potential — resolves boundary layers
  • Fully nonlinear — no assumptions
  • Extremely well validated across industries
  • Rich ecosystem of solvers and tools
  • ParaView visualization — excellent output
  • Can predict drag forces accurately

Limitations

  • CPU-only — very slow compared to GPU methods
  • Mesh generation required — adds setup complexity
  • Long wall-clock times (days) for real sea states
  • Steep learning curve for case setup
  • Dynamic mesh can fail for very large motions
  • Not practical for parameter sweeps
Best-in-class accuracy but impractical for routine use on your seastead due to CPU-only speed. Ideal for validating a few critical cases from your SPH simulations. Set up one or two "validation runs" comparing DualSPHysics results against OpenFOAM to build confidence, then use SPH for your main design iteration.

Reef3D

Website · GitHub

Reef3D is an open-source CFD code specifically built for coastal and ocean engineering. It solves the Reynolds-Averaged Navier-Stokes (RANS) equations with a VOF (Volume of Fluid) free surface, similar to OpenFOAM's approach but with a focus on wave-structure interaction from the start. It has excellent wave generation and absorption built in, and supports floating body dynamics.

For your seastead: Reef3D would handle the nonlinear hydrodynamics correctly. It's been used for floating offshore platforms, breakwaters, and similar structures. However, like OpenFOAM, it is CPU-based (with OpenMP parallelism only) and will be significantly slower than GPU-accelerated SPH.

Strengths

  • Purpose-built for coastal/ocean engineering
  • Excellent wave generation and absorption
  • Fully nonlinear CFD — high accuracy
  • Good validation for floating bodies
  • Clean, focused codebase

Limitations

  • CPU-only — no GPU acceleration
  • No Python API — configuration via text files
  • Smaller community than OpenFOAM or DualSPHysics
  • Mesh generation still required
  • Slower iteration cycle
A strong CFD option that's more focused on marine engineering than general-purpose OpenFOAM, but still hampered by CPU-only speed. Good as a secondary validation tool alongside DualSPHysics.

SPlisHSPlasH

Website · GitHub

SPlisHSPlasH is an open-source SPH simulator from the University of Freiburg with CUDA GPU acceleration and Python bindings. It supports multiple SPH methods (WCSPH, PCISPH, PBF, DFSPH) and has rigid-fluid coupling. It's well-known in computer graphics and increasingly used for engineering applications.

Caveat for your case: SPlisHSPlasH originates from the computer graphics community. While its physics is genuine SPH (not "fake"), the emphasis has been on visual quality and speed rather than engineering validation for offshore structures. It may not have the same level of validation for wave forces, hydrostatics, and seakeeping as DualSPHysics. Wave generation features are less mature.

Strengths

  • GPU-accelerated (CUDA)
  • Python bindings available
  • Nice real-time visualization
  • Multiple SPH solvers to choose from
  • Active development

Limitations

  • Less validated for marine/offshore engineering
  • Wave generation is limited
  • Rigid body coupling less mature than Chrono
  • Computer graphics heritage may show in accuracy edge cases
Technically capable of your simulation, but the marine engineering track record is thin. If you're comfortable being an early adopter and cross-validating against a more established tool, it could work. Otherwise, DualSPHysics is the safer SPH choice.

Capytaine (+ MoorDyn)

GitHub · MoorDyn

Capytaine is an excellent BEM solver with a beautiful Python API. It computes frequency-dependent added mass, radiation damping, and diffraction forces for floating bodies. MoorDyn provides mooring line dynamics. Together they can simulate a moored seastead in waves.

The fundamental problem: Capytaine is a BEM solver. It linearizes around the mean waterline. For your seastead where the legs go from 50% to ~100% submerged, BEM will incorrectly predict: (1) heave restoring force (which depends on waterplane area that changes dramatically), (2) roll/pitch damping (which changes as more of the foil is submerged), and (3) wave forces in large seas where the body motions are not small relative to the wave amplitude.

Where it IS useful: Capytaine can give you quick estimates of natural periods (heave, roll, pitch) and Response Amplitude Operators (RAOs) for small to moderate sea states. This is valuable for initial design screening — if your natural period in heave coincides with the peak wave period, you know you have a problem before running expensive SPH simulations. Think of it as a "first pass" tool.

Strengths

  • Excellent Python API — easy to automate
  • Very fast — seconds to minutes per run
  • Great for initial design screening
  • MoorDyn adds realistic mooring dynamics
  • Can generate RAOs quickly
  • Well documented

Limitations

  • BEM — linear assumptions only
  • Inaccurate for large draft changes (your main concern!)
  • Cannot capture viscous damping from NACA foils
  • Cannot predict wave breaking or slamming
  • Misleading results in extreme seas
Use only for preliminary design screening in small to moderate waves. Do NOT trust BEM results for the extreme wave conditions you're most concerned about. Run a few Capytaine cases first to understand natural periods and RAOs, then move to SPH for the real answers.

WEC-Sim + MoorDyn

Website

WEC-Sim is a MATLAB/Simulink-based time-domain solver for wave energy converters and floating bodies. It uses BEM hydrodynamic coefficients (from NEMOH, Capytaine, or WAMIT) and solves the equations of motion in the time domain with nonlinear mooring and power take-off forces.

It has the same BEM limitation as Capytaine — the hydrodynamic forces are linearized. WEC-Sim does offer a "nonlinear buoyancy" option that recomputes hydrostatic forces from the instantaneous wetted surface, which is a step in the right direction. But the radiation and diffraction forces are still linear.

MATLAB Cost Estimate — Non-Student, Anguilla

Anguilla is a British Overseas Territory. MATLAB pricing is typically at the international/commercial rate:

  • MATLAB (base): ~$2,150/year or ~$4,300 perpetual
  • Simulink: ~$2,900/year or ~$5,800 perpetual
  • Simscape Multibody: ~$1,500/year or ~$3,000 perpetual
  • Total annual subscription: approximately $6,500–$8,000/year
  • Total perpetual: approximately $13,000–$16,000+

WEC-Sim itself is free, but it's useless without the MATLAB infrastructure. Note: These are list prices — actual pricing requires a quote from MathWorks and may vary.

Strengths

  • Purpose-built for marine energy devices
  • Nonlinear hydrostatics option available
  • MoorDyn integration
  • Good documentation and examples

Limitations

  • Requires MATLAB + Simulink + Simscape = $$$
  • Not truly open source (depends on proprietary MATLAB)
  • Still relies on BEM for radiation/diffraction
  • No GPU acceleration
  • Limited nonlinear capability vs. SPH/CFD
Not recommended. High cost for MATLAB/Simulink/Simscape, still fundamentally a BEM-based approach, and no GPU acceleration. The nonlinear hydrostatics option is a partial improvement but doesn't address the core limitation. Your money and time are better invested in SPH or CFD.

Blender Physics Simulation

blender.org

Blender's built-in fluid simulation (MantaFlow) uses FLIP or SPH methods and produces beautiful visual output. Its Python API is powerful, and you could theoretically set up a seastead-in-waves scene.

However, Blender's physics are not engineering-grade. The fluid solver is optimized for visual appeal, not physical accuracy. Key problems: (1) SPH/FLIP implementations lack the numerical corrections needed for accurate pressure fields in engineering problems; (2) rigid body-fluid coupling is not properly two-way coupled for engineering force accuracy; (3) there's no validation against experimental data for hydrodynamic forces; (4) boundary conditions are not suitable for ocean wave propagation over significant distances. This has not changed as of 2024.

There's no known add-on or project that makes Blender suitable for engineering hydrodynamics. It's excellent for producing beautiful renderings of your seastead for marketing materials (using simulation results from DualSPHysics as reference), but not for the simulation itself.

Strengths

  • Beautiful visualization and rendering
  • Powerful Python API
  • Fast to get something visual running
  • Free and well-known

Limitations

  • Physics not validated for engineering
  • Fluid-body coupling is not accurate
  • No proper wave generation for ocean engineering
  • Force calculations are not trustworthy
  • Will give misleading results for your design
Do not use Blender for engineering simulation. Use it to create beautiful visualizations of your design, but the physics answers it gives you cannot be trusted for safety-critical engineering decisions. The risk of "looking right but being wrong" is high.

OpenFAST (NREL)

GitHub

OpenFAST is NREL's open-source aero-hydro-servo-elastic tool for offshore wind turbines. Its HydroDyn module provides hydrodynamic forces using BEM (potential flow) with Morison equation corrections for slender members. It handles moorings via MoorDyn and has a mature time-domain solver.

For your seastead: OpenFAST could model the three legs as slender Morison elements (which is reasonable for the NACA foils at subcritical Reynolds numbers) and the platform as a rigid body. The Morison equation is inherently nonlinear (the drag term is quadratic). However, OpenFAST is built around the assumption of a single rigid platform with tower + rotor, not a generic trimaran-like structure. Customization would require significant effort.

Strengths

  • Open source, well maintained by NREL
  • Morison equation handles nonlinear drag
  • MoorDyn integration
  • Proven in offshore engineering

Limitations

  • BEM for potential flow — same linear problem
  • Designed for wind turbines — hard to adapt
  • No visualization to speak of
  • Not designed for your type of structure
  • Configuration files are complex and domain-specific
Too specialized for offshore wind turbines. Adapting it for a seastead trimaran would require more effort than using a general-purpose SPH or CFD tool, and you'd still have BEM limitations for the potential flow part. Not worth the detour.
Effort Estimation

Time to First Simulation

Estimated time to get your specific seastead design running in waves with visualization, assuming Claude Code / Cursor.ai assistance and ~4 hours/day of focused work.

Software Steps Required Est. Time Biggest Bottleneck
DualSPHysics + Chrono Install, create STL geometry, write XML case file, configure Chrono coupling, set wave parameters, run, post-process in ParaView 2–3 weeks Chrono coupling configuration and getting the 6-DOF body parameters right
Chrono FSI-SPH (PyChrono) Install PyChrono, write Python script defining body + SPH domain, configure FSI, run, post-process 2–4 weeks FSI-SPH documentation gaps; may need to read source code
OpenFOAM (interDyMFoam) Install, create STL geometry, mesh with snappyHexMesh, set up case (0/, constant/, system/), configure wave boundaries, run, post-process 4–6 weeks Mesh generation and dynamic mesh stability
Reef3D Install, create STL geometry, configure input files, set wave parameters, run, post-process 4–6 weeks Less documentation; mesh generation
SPlisHSPlasH Install, write Python/JSON scene file, configure SPH parameters, add wave boundary, run, post-process 3–5 weeks Marine wave generation features are immature
Capytaine + MoorDyn pip install, create mesh (pyMesh or STL), define body, run BEM, couple with MoorDyn in Python, plot results 1–2 weeks Accuracy limited to linear regime (but fast to set up!)
Blender Install, model geometry, set up MantaFlow domain, run, render 1–2 weeks Results are not engineering-accurate
Workflow

How Hard to Simulate a Different Design?

Once you have your first seastead model running, here's how much effort to swap in a new design variant.

Software What Changes Between Designs Effort to Iterate Automation Potential
DualSPHysics + Chrono New STL geometry file, updated mass/inertia in XML, possibly adjust particle spacing 1–3 days High — Claude Code can generate XML, Python scripts can parameterize geometry
Chrono FSI-SPH New geometry in Python script, updated body properties 1–2 days Excellent — everything is in Python, easy to parameterize
OpenFOAM New STL, regenerate mesh, possibly adjust mesh parameters, re-run 3–5 days Moderate — mesh generation can be scripted but is finicky
Reef3D New geometry, possibly adjust grid resolution 3–5 days Moderate — text file configuration
SPlisHSPlasH New geometry in Python/JSON, adjusted parameters 1–3 days Good — Python-based scene description
Capytaine New mesh, updated body properties — all in Python Hours Excellent — pure Python, fast sweeps across many designs
Key insight: SPH methods have a major advantage in design iteration — there's no mesh to generate. You just swap the STL file (or change the Python geometry definition) and re-run. OpenFOAM's mesh generation step adds significant friction to the iteration cycle. This is one of the strongest arguments for SPH as your primary design tool.
Action Plan

Recommended Simulation Roadmap

A staged approach that gets you answers fast while building toward high-fidelity simulation capability.

Phase 1 — Week 1-2

Quick Screening with Capytaine

Set up your seastead as a BEM model in Capytaine. Compute natural periods in heave, roll, and pitch. Generate RAOs for small to moderate waves. Identify problematic wave periods. This costs almost no compute time and gives you a baseline understanding of your platform's dynamics. Do not trust these results for extreme waves — but they'll tell you if your heave period is dangerously close to typical wave periods, for example. With Claude Code, this can be running in 3–5 days.

Phase 2 — Week 2-4

Primary Nonlinear Simulation with DualSPHysics + Chrono

Install DualSPHysics, create STL geometry of your seastead legs and frame, configure the Chrono coupling for 6-DOF rigid body dynamics, and set up regular wave cases (Sea State 3, 4, 5). Start with smaller waves where you can compare against Capytaine results (they should agree for small waves), then push to larger waves where they diverge. Visualize in ParaView and create videos. Measure accelerations at the living quarters location. This is your main design iteration tool going forward.

Phase 3 — Week 4-5

Irregular Sea Simulations

Run DualSPHysics with irregular (JONSWAP or Pierson-Moskowitz) wave spectra representing target sea states. Find the wave height where your seastead's legs approach full submersion. Quantify maximum roll angles, heave accelerations, and deck clearances. Run multiple realizations for statistical confidence. Each simulation may take 6–24 hours on your GPU.

Phase 4 — Week 5-8

Cross-Validation with OpenFOAM (Optional but Recommended)

Pick 2–3 critical cases from your DualSPHysics results (a moderate wave case and an extreme case). Replicate these in OpenFOAM with interDyMFoam. Compare heave, roll, and acceleration time histories. If they agree within 10–15%, you have high confidence in your DualSPHysics results. If they disagree, investigate which is more correct. This is slow (days per case) but gives you the engineering justification to trust your primary tool.

Phase 5 — Ongoing

Design Iteration and Failure Analysis

Use DualSPHysics as your primary design tool. Test different leg shapes, sizes, spacing, and mass distributions. For each design variant, swap the STL geometry, update the XML configuration, and re-run. Document the wave conditions where each design fails (excessive roll, leg submersion, deck submergence, structural overload). Build a design space map showing safe operating envelopes.

Future Enhancement

Add Stabilizers, Moorings, and Propulsion

Once the basic hydrodynamics are validated, extend the simulation: (1) Add the 3 stabilizer fins as separate Chrono rigid bodies with actuated joints — simulate their effectiveness at reducing roll; (2) Add MoorDyn mooring lines if you need station-keeping; (3) The RIM drive thrusters can be modeled as prescribed forces on the body. Chrono's multibody framework makes all of these natural extensions.

Common Questions

Frequently Asked Questions

Can I run DualSPHysics on Windows?
Yes. DualSPHysics provides pre-compiled Windows executables. The GPU version requires an NVIDIA GPU with CUDA support (which you have). The CPU version works on any Windows machine. However, for large production runs, Linux typically gives 10–20% better GPU performance due to lower driver overhead. You can dual-boot or use WSL2 for the best of both worlds.
How many SPH particles do I need for my seastead?

For your 80×40 ft (24×12 m) seastead with 19 ft (5.8 m) legs in 3–4 m waves:

  • Coarse screening (dp = 0.1 m): ~500K–1M particles → fast runs, approximate results
  • Design iteration (dp = 0.05 m): ~3–5M particles → good balance of speed and accuracy
  • Final validation (dp = 0.025 m): ~20–40M particles → high accuracy, slow runs

Always run at least two resolutions and check convergence. An RTX 3080/3090/4080/4090 can handle 5M particles comfortably for regular wave simulations.

How do I create the NACA foil geometry for the legs?

Generate the NACA foil coordinates using Python (the pymesh or manual parametric equations), then create a 3D extrusion and export as STL. This is straightforward — Claude Code can write a Python script that takes the NACA parameters, chord, span, and outputs an STL file. For DualSPHysics, the STL needs to be a closed, watertight mesh. Tools like FreeCAD or OpenSCAD can also help.

Can I measure accelerations at specific points on the seastead?

Yes. In the Chrono coupling, your seastead is a rigid body with known position, orientation, and their derivatives. The acceleration at any point P on the body is: aP = aCG + α × rP + ω × (ω × rP), where aCG is the CG acceleration, α is angular acceleration, ω is angular velocity, and rP is the vector from CG to point P. You can output all of these from Chrono and compute accelerations at the living quarters, front deck, or any other location. DualSPHysics+Chrono outputs these by default.

What about SPH particle resolution near the thin NACA foils?

This is a legitimate concern. SPH resolves geometry at the particle spacing scale. If your NACA foil has a 3 ft (0.9 m) max width and you use dp = 0.05 m, you get about 18 particles across the width — adequate. But if you need to resolve the thin trailing edge, you'd need very fine resolution. In practice, slightly thickening the trailing edge of the STL for simulation purposes is acceptable and common. The hydrodynamic forces are dominated by the pressure distribution around the thick part, not the thin trailing edge. Alternatively, you can use the Chrono coupling which represents the body as a boundary — the body surface is exactly defined by the STL mesh, not by particle resolution.

Can I automate running many wave conditions?

Absolutely. Write a Python script that generates DualSPHysics XML input files for different wave heights, periods, and headings. Each case runs independently and can be queued. You can sweep across Sea State 2 through Sea State 6, or vary wave heading from head seas to beam seas to quartering seas. Claude Code can write this automation script. Results can be automatically post-processed to extract maximum roll angle, maximum heave acceleration, etc., and plotted as contour maps over the wave condition space.

Is there a way to do real-time or interactive simulation?

Not at engineering resolution. At very coarse resolution (dp = 0.2–0.3 m), DualSPHysics can run faster than real-time on a powerful GPU, but the results are too coarse for engineering decisions. At design resolution, expect 10–100× slower than real-time. This is normal for SPH — a 30-second physical event might take 5–50 minutes of GPU time. Interactive simulation is an active research area but not yet practical for engineering work at the resolution you need.

How do I make videos like the one in my YouTube link?

DualSPHysics outputs VTK files at specified intervals. Load these into ParaView (free), which has excellent animation capabilities. You can: (1) color the water particles by velocity or pressure; (2) show the seastead as a solid body; (3) add time and wave height annotations; (4) export as AVI/MP4 video. ParaView also supports Python scripting, so you can automate the visualization pipeline. For higher production quality, you can export simulation results and render in Blender's Cycles engine, but this adds a post-processing step.

What if I also want to simulate the seastead under propulsion?

For propulsion, you have two options: (1) In the Chrono coupling, add prescribed forces at the thruster locations on each leg. The force magnitude can be a constant or a function of time. This is simple and captures the effect of thrust on the body dynamics. (2) For more accuracy, model the thruster wake and its interaction with the NACA foils — this would require either CFD (OpenFOAM with actuator disk models) or a more sophisticated SPH setup. Option 1 is recommended for initial design work. The RIM drive thrusters are relatively small compared to wave forces, so a simple force model is likely sufficient.

Bottom Line

Summary of Recommendations

Use This

DualSPHysics + Chrono

Primary simulation tool. Fully nonlinear, GPU-accelerated, validated for floating bodies, good visualization. Your workhorse for design iteration.

Also Consider

Chrono FSI-SPH (PyChrono)

Excellent Python integration, unified framework. Less marine validation than DualSPHysics. Great if you want everything scriptable in Python and plan to add stabilizers/moorings later.

Validate With

OpenFOAM

Run 2–3 cross-validation cases to build confidence in your SPH results. Highest accuracy but too slow for routine use. CPU-only.

Quick Screening

Capytaine

Fast BEM for natural periods and small-wave RAOs. Limited accuracy for your nonlinear problem, but runs in seconds. Use as a first pass only.

2–3
Weeks to first simulation
0
Linear assumptions (with SPH)
1–3
Days to iterate on new design
$0
Software cost (DualSPHysics)
$7K+
MATLAB cost you avoid
``` ## Key Takeaways **Your intuition about BEM being insufficient is correct.** When your 19-foot legs transition from 50% to nearly 100% submerged, every hydrodynamic coefficient changes nonlinearly. BEM solvers (Capytaine, NEMOH, the BEM mode of Project Chrono, WEC-Sim) all linearize around the mean waterline — they will give you misleading results precisely when the waves get dangerous. **DualSPHysics + Chrono is your best bet** because it hits all your requirements simultaneously: fully nonlinear physics, native GPU acceleration (your powerful GPU gets put to work), mature Chrono coupling for 6-DOF rigid body dynamics, ParaView visualization for videos, and it's genuinely free. The Chrono coupling directly addresses your need to track accelerations at arbitrary points on the structure. **Important clarification on Chrono:** When you use `Chrono::FSI-SPH`, Chrono is **not** using BEM at all. The FSI-SPH module is a completely separate code path that uses particle-based fluid simulation — fully nonlinear, no linearization. It's only the "offshore" module that imports BEM coefficients from external solvers. **The recommended phased approach** starts with a quick Capytaine screening (1-2 weeks) to understand natural periods, then builds your main simulation capability with DualSPHysics (2-3 weeks more), optionally cross-validates with OpenFOAM (slow but gold-standard accuracy), and then uses DualSPHysics as your primary design iteration tool going forward. Swapping in a new seastead variant is just a matter of changing the STL geometry file — typically 1-3 days of effort with Claude Code helping.