Installation

There are two ways to get CableDyn:

  • Windows release (recommended for users). Two single-file executables and a Python wheel, attached to the v0.1.0 GitHub release. No installer, no compiler, and no runtime DLLs. Start here if you want a first result in five minutes.

  • Build from source (Windows, Linux, macOS). Needed for the C/Python in-process API, for development, and on every platform other than Windows x64.

Windows release

What is on the release page

Asset

What it is

CableDyn_driver.exe

the standalone solver: reads a CableDyn .dat deck, writes .out tables (Standalone Windows driver)

openfast.exe

OpenFAST v5.0.0 (maintained by NLR, the National Laboratory of the Rockies, formerly NREL) with CableDyn built in as CompMooring = 5; stock MoorDyn (CompMooring = 3) is still available in the same binary (OpenFAST with CompMooring = 5)

cabledyn-0.1.0-py3-none-any.whl

the pure-Python package: deck editing, case generation, driver automation, result readers, fatigue and spectral post-processing (Python package)

cabledyn-0.1.0.tar.gz

the Python source distribution (same package as the wheel)

SHA256SUMS.txt

SHA-256 checksums of the four files above

Source code (zip) / (tar.gz)

the complete repository at the release tag, generated by GitHub. This is where the example decks live (the examples/ folder).

Important

The executables do not contain example decks. Every tutorial in this manual runs a deck from the examples/ folder of the Source code (zip) archive on the same release page. Download it once and unzip it next to the executables.

Download and verify

  1. Create a folder, for example C:\CableDyn, and download into it CableDyn_driver.exe, openfast.exe (only if you will couple with OpenFAST), cabledyn-0.1.0-py3-none-any.whl (only if you will use Python), SHA256SUMS.txt, and Source code (zip).

  2. Verify every downloaded asset against SHA256SUMS.txt in PowerShell:

    Set-Location C:\CableDyn
Get-Content .\SHA256SUMS.txt | ForEach-Object {
    $expected, $name = $_ -split '\s+', 2
    if (-not (Test-Path -LiteralPath $name)) { "not downloaded  $name"; return }
    $actual = (Get-FileHash -Algorithm SHA256 -LiteralPath $name).Hash.ToLowerInvariant()
    if ($actual -eq $expected) { "OK              $name" } else { "MISMATCH        $name" }
}

    With the driver, openfast.exe, and the wheel downloaded, the output is:

    OK              CableDyn_driver.exe
OK              openfast.exe
OK              cabledyn-0.1.0-py3-none-any.whl
not downloaded  cabledyn-0.1.0.tar.gz

    not downloaded only reports an asset you chose to skip.

    Any MISMATCH means the file is corrupt or is not the published asset: delete it and download it again. To check a single file by eye, compare (Get-FileHash .\CableDyn_driver.exe -Algorithm SHA256).Hash with its line in SHA256SUMS.txt (the comparison is case-insensitive).

  3. Unzip Source code (zip). It expands to a folder such as CableDyn-0.1.0; copy (or move) its examples folder into C:\CableDyn so the layout is:

    C:\CableDyn\
    CableDyn_driver.exe
    openfast.exe
    SHA256SUMS.txt
    examples\
        chain_catenary_shallow_30m.dat
        ...

  4. Windows SmartScreen may warn that the executable is from an unknown publisher the first time it runs. Choose More info → Run anyway only after the checksum above reads OK. If your browser marked the files as downloaded from the internet, Unblock-File .\*.exe clears the flag.

Check that it runs

.\CableDyn_driver.exe --version

===================================================================
  CableDyn  v0.1.0
  Geometrically nonlinear cable & mooring dynamics for floating wind
  (lazy-wave power cables and taut / semi-taut / catenary moorings)
-------------------------------------------------------------------
  Author    Prof. Jae Hoon Seo
  Affil.    Inha University, Republic of Korea
  License   Apache-2.0     github.com/SMI-Lab-Inha/CableDyn
===================================================================

The exit code is 0. Both executables are statically linked x64 programs: they need no Intel, MKL, GNU Fortran, OpenMP, OpenBLAS, or Visual C++ runtime DLL and run on a clean Windows 10 (version 1903 or later) or Windows 11 machine. (An OpenFAST turbine model may still name its own controller DLL, such as DISCON.dll, in ServoDyn; that belongs to the turbine model, not to CableDyn.)

Run from any folder

Nothing has to be installed. Either call the executable by its full path (the driver does not create the output folder, so create it first):

New-Item -ItemType Directory -Force results | Out-Null
C:\CableDyn\CableDyn_driver.exe .\model.dat .\results\run1

or add its folder to your user PATH once, then open a new terminal:

$userPath = [Environment]::GetEnvironmentVariable('Path', 'User')
[Environment]::SetEnvironmentVariable('Path', "$userPath;C:\CableDyn", 'User')

After that, CableDyn_driver.exe and openfast.exe work from any directory. Relative paths on the command line are resolved from the current directory; paths inside a deck (motion, bathymetry, WaterKin, and Syrope files) are resolved from the deck’s own folder. Folder and file names may use any script: both executables run with UTF-8 as their Windows code page, whatever the system locale. See Standalone Windows driver for the full path rules.

Python package

The wheel is pure Python (NumPy is its only required dependency) and works on any platform with Python 3.10 or newer:

py -m pip install .\cabledyn-0.1.0-py3-none-any.whl
# optional extras for DataFrames and plots:
py -m pip install ".\cabledyn-0.1.0-py3-none-any.whl[post]"

This installs the cabledyn package and four console commands: cabledyn-run, cabledyn-deck, cabledyn-study, and cabledyn-post.

The package drives the solver as a subprocess; it does not contain the solver. It finds CableDyn_driver.exe in this order:

  1. an explicit path, CableDynDriver(r"C:\CableDyn\CableDyn_driver.exe") or cabledyn-run --executable ...;

  2. the CABLEDYN_DRIVER environment variable (the full path to the executable);

  3. the first CableDyn_driver.exe, CableDyn_driver, or cabledyn on PATH.

If none is found it raises DriverNotFoundError listing every location it tried. To set the variable for your user account:

[Environment]::SetEnvironmentVariable('CABLEDYN_DRIVER', 'C:\CableDyn\CableDyn_driver.exe', 'User')

Check the installation from a new terminal:

py -c "import cabledyn; from cabledyn import CableDynDriver; print(cabledyn.__version__, CableDynDriver().executable)"

0.1.0 C:\CableDyn\CableDyn_driver.exe

The in-process API (cabledyn.CableDyn, stepping the solver from Python without a subprocess) additionally needs the shared library from a source build; see Python package.

Updating

Download the new release assets into a new folder, verify them with the same checksum loop, and repoint PATH / CABLEDYN_DRIVER. Keep the old folder until you have re-run one known case and compared results; archive the executable’s SHA-256 with every production result.

Build from source

The source build produces the same solver plus the shared C library (libcabledyn), the C header, and the full test suite. The reproducible toolchain on every platform is the conda environment in environment.yml (GNU Fortran, a C compiler, CMake ≥ 3.20, Ninja, Make, OpenBLAS/LAPACK, Python, NumPy). Do not mix the conda gfortran with a system gfortran or with Intel IFX in one build tree.

Get the source from the release page (Source code) or clone it:

git clone https://github.com/SMI-Lab-Inha/CableDyn.git
cd CableDyn

Windows (conda + GNU Fortran)

From an Anaconda/Miniforge PowerShell prompt in the repository root:

conda env create -f environment.yml
conda activate cabledyn
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build
ctest --test-dir build -L fortran -LE slow

Pass -G Ninja so CMake does not pick a Visual Studio generator. GNU Windows builds place the executables and their runtime DLLs together in build\bin. The deck driver is build\bin\cabledyn.exe; it takes exactly the same arguments as CableDyn_driver.exe.

Unlike the release executable, this build depends on the GNU and OpenBLAS DLLs. Run it from the activated environment, or stage a self-contained copy with its DLLs:

cmake --install build --prefix stage     # stage\bin\cabledyn.exe + required DLLs

Windows (Intel IFX, static release)

The published single-file executables are built with Intel IFX 2025.3 or newer with interprocedural optimisation (/Qipo), the static MSVC runtime, and the netlib reference LAPACK/BLAS 3.12.1 compiled with the same IFX for CableDyn’s narrow banded systems. From a machine with Visual Studio 2022 (x64 C++ tools) and Intel oneAPI, with a clean OpenFAST checkout and an OpenFAST r-test checkout:

.\release\build_static_windows.ps1 -OpenFASTRoot ..\openfast -RTestRoot ..\r-test

The script downloads the LAPACK source from its release tag and verifies its SHA-256 (pass -ReferenceLapackArchive <lapack-3.12.1.tar.gz> to build offline). It applies the CableDyn integration to OpenFAST itself (do not pre-apply it), builds both executables, rejects any non-system DLL import, runs a standalone and a coupled CompMooring = 5 / CompMooring = 3 smoke case with a system-only PATH, and writes SHA256SUMS.txt into build-static-release\dist. The v0.1.0 assets were built from OpenFAST revision 2895884d2be01862173c88d70f86b358d2f1a50a and smoke-tested against r-test revision dd5feaaaa500ba7283140107806300d551cff0a7.

Linux

conda env create -f environment.yml
conda activate cabledyn
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build
ctest --test-dir build -L fortran -LE slow
./build/cabledyn --version

On Linux and macOS the deck driver is build/cabledyn. A distribution toolchain also works if it provides gfortran, a C compiler, CMake ≥ 3.20, and LAPACK/BLAS (for example gfortran cmake ninja-build liblapack-dev libopenblas-dev on Debian/Ubuntu); the conda route is the one exercised by continuous integration.

macOS

The same conda commands as Linux apply; environment.yml resolves on both osx-64 and osx-arm64. Continuous integration runs on Linux and Windows, so run the fast test tier after building on a Mac before trusting results.

Install the build

cmake --install build --prefix stage

installs the deck driver, the shared C library, the public C header (CableDyn_CAPI.h), and the import library. Point CABLEDYN_DRIVER at stage/bin/cabledyn (.exe on Windows) to use it from Python, and install the Python package from the source tree with python -m pip install ./python.

Update a source build

git pull
conda env update -f environment.yml
cmake --build build
ctest --test-dir build -L fortran -LE slow

If the CMake configuration changed or a stale tree misbehaves, reconfigure from a fresh cache (cmake -S . -B build --fresh with CMake ≥ 3.24, otherwise delete build/ first). Never copy a build tree between compilers or operating systems. The coupled OpenFAST module is built inside an OpenFAST source tree, not in build/; see Coupling: OpenFAST and CFD.

Build the documentation

python -m pip install -r doc/requirements.txt
python -m sphinx -b html -W --keep-going -n doc build/docs-html

The build treats warnings, including unresolved cross-references (-n), as errors.

Next steps