Overview of Wake CFD

NoteTechnical Preview Documentation

This documentation is published ahead of the public solver release to introduce Wake CFD’s capabilities and workflows.

The documentation is actively maintained and updated frequently. Features, input settings, screenshots, and examples may change as development progresses, and some documented capabilities may not yet be available in publicly distributed builds.

Public solver availability will be announced separately. When using Wake CFD, refer to the documentation and release notes applicable to your installed version.

Wake CFD is a computational fluid dynamics (CFD) software suite designed to meet the analysis requirements of the aero-defense industries, and built for a new way of working: engineers and AI agents setting up, running, and reviewing the same case together. Its distinguishing features are:

  • Built for AI agents from the start. An AI agent works on a case the way an engineer does — in the same project, with the same commands, checked by the same validation. Its changes appear in the open Desktop project at once, and the engineer’s changes are visible to the agent. So neither side needs a separate script or an export step to see the other’s changes.

  • One platform from design iteration to high-fidelity analysis. Density-based and pressure-based finite-volume solvers and a high-order flux-reconstruction solver share one case model, one interface, and one workflow. A case can move from fast steady RANS design iterations to high-order unsteady analysis without being set up again in another tool.

  • A GPU-native solver. The solver was written for the GPU from the start, not ported to it: the complete implicit solution — flux Jacobians, preconditioning, and the linear solver — runs on the GPU, so a single workstation GPU delivers turnaround that otherwise needs a cluster.

  • The same physics on GPU and CPU. GPU and CPU builds are compiled from one source of the numerical method, so every feature is available on both and their results agree to round-off. A deterministic mode reproduces a run bit for bit.

  • Readable cases with a full GUI. A case set up in the Desktop is a readable text file: it can be compared, reviewed, and kept under version control, and it runs unchanged from the command line, from Python, or on an HPC system.

Every run also keeps the input it read and the solver build that ran it, and the solver’s own validation checks each case before any computing time is spent.

Wake CFD can model:

  • steady and unsteady (physical-time) flows,
  • inviscid (Euler), laminar, and turbulent flows — Spalart–Allmaras and k-ω SST RANS models, with wall functions or wall-resolved meshes,
  • subsonic, transonic, and supersonic compressible flows,
  • ideal and thermally perfect gases,
  • heat transfer in solids and conjugate heat transfer between fluid and solid,
  • rotating machinery: rotating domains, frozen-rotor, mixing-plane (stage), and sliding interfaces, and moving walls,
  • periodic and non-conformal (GGI) interfaces,
  • axisymmetric flows in 2D,
  • boundary and initial values given as expressions of position and time.
Note

Version and scope. Solver availability, platform support, and settings depend on the installed build. Record the Wake CFD version with every engineering result — each run folder already records it.

The structure of Wake CFD

Wake CFD consists of the following components:

Component What it does
Wake CFD Desktop Sets up projects and cases — meshes, physics, boundary conditions, numerics, outputs — and runs, stops, and monitors them on this computer
Wake CFD Solver Solves the case. One executable per dimension, precision tier, and device: for example wake_3d_mixed (3D, Mixed precision) as a GPU or a CPU build
Python SDK (pyWakeCFD) Builds, runs, and monitors cases from Python scripts — parameter sweeps and batch work
AI agent connection Lets an AI agent that supports the Model Context Protocol (MCP) work on the open Desktop project or on a project of its own

Volume, surface, and slice results are written in ParaView formats and reviewed in ParaView; convergence histories are CSV files, also charted in the Desktop.

Diagram: Desktop GUI, CLI, Python SDK, and AI agent all read and write one case model; the model runs on the DBNS (production), PBNS, or FR (in development) solver path, on GPU or CPU builds; each run writes a run folder with the input as read, the solver version and build, the convergence history, field results, and a restart, which feed result review and validation
Figure 1: One case model is shared by the Desktop GUI, the CLI, the Python SDK, and AI agents. It runs on the DBNS, PBNS, or FR solver path, on GPU or CPU builds, and each run writes a self-describing run folder for result review and validation.

One case model

The Desktop, the command line, the Python SDK, and AI agents all use the same case model, stored as a readable text file (JSONC). It describes the mesh, the analysis, materials and physical models, domains and boundary conditions, the numerical method, run control, monitoring, and outputs. A case therefore moves from interactive setup to a scripted or HPC run without being translated into another format.

Solver paths

The solver offers three numerical formulations through the same case model. Choose the formulation from the flow physics and the numerical behavior you need, not from the mesh format or the interface.

Formulation Best suited to Scope Status
DBNS — density-based Navier–Stokes Compressible external aerodynamics, transonic and supersonic flow, turbomachinery 2D and 3D; Euler, laminar, and RANS Production
PBNS — pressure-based Navier–Stokes Low-Mach and incompressible flow, including internal flow 3D In development
FR — flux reconstruction High-order, unsteady, and vortex-dominated flow 2D and 3D; polynomial order 1–4 In development

Agentic CFD: working with an AI agent

Wake CFD is built so that an AI agent can work on a CFD case the way an engineer does — through the same project, the same commands, and the same validation. An agent that supports MCP, such as Claude Code, connects to Wake CFD Desktop or runs a project on its own, and can:

  • set up a case from a description — create the project, register meshes, read their zones and boundary markers, and build domains, boundary conditions, materials, numerics, outputs, and monitors;
  • check its own work — every edit is judged by the solver’s own validation, which returns the exact setting and reason for each problem, so the agent corrects the case before it runs;
  • run and watch — start and stop runs, follow residuals and monitors, and read why a run ended;
  • work alongside the engineer — changes the agent makes appear in the open Desktop project at once, and changes the engineer makes are visible to the agent. The agent’s case is the engineer’s case.

Every result stays traceable: the run folder records the exact input and the solver build, whether the run was started by a person or by an agent. The engineer remains responsible for reviewing the setup and judging the result. See Connect an AI agent.

Getting started with Wake CFD

  1. Install Wake CFD.
  2. Run the packaged ONERA M6 half-wing example: the ONERA M6 quickstart uses the Desktop and shows the command-line run as well.
  3. Keep that result as a baseline before changing the mesh, boundary conditions, or physical model.

To start the Desktop, choose Wake CFD Desktop from the Start menu on Windows, or run wake-cfd-desktop from the installation’s app/<platform>/ folder (see The directory structure). To run a case from the command line, call the solver for the case’s dimension with the case file, in the folder that holds it:

wake_3d_mixed case.jsonc

Names

Case names become folder names on disk. A name can hold letters, digits, spaces, and most punctuation, but not / \ : * ? " < > |, control characters, or a trailing dot or space, and it cannot be a name Windows reserves (CON, NUL, COM1, …). Use a period as the decimal separator in every numeric field.

The directory structure of Wake CFD

An installation is a versioned folder, so several releases can be installed side by side:

wakecfd/
├── license/                  license files (.lic) and wakecfd_license.ini
└── v<X.Y.Z>/                 one release
    ├── app/<platform>/       Wake CFD Desktop and the AI agent connection
    ├── solver/<platform>/
    │   ├── gpu-nvidia/       NVIDIA GPU solver builds, wake_grid, wake_lic
    │   ├── gpu-amd/          AMD GPU solver builds, wake_grid, wake_lic (when included)
    │   └── cpu/              CPU solver builds, wake_grid, wake_lic (when included)
    └── shared/
        ├── input-reference/  the input reference and schemas
        ├── examples/         example cases with their meshes
        └── python/           the Python SDK (pyWakeCFD)

<platform> is win-x64, linux-x64, or linux-arm64. Solver executables are named wake_<dimension>d_<precision> — for example wake_2d_mixed or wake_3d_fp64 — with .exe on Windows. Keep the folders as installed: the executables use the libraries next to them.

Wake CFD file types

File Written by Purpose
<name>.wakeproj Desktop A Desktop project: project information, meshes, and cases
<name>_files/ Desktop The project’s data: cases, project copies of meshes, and runs
<case>.jsonc Desktop, user, scripts A case for the solver (a solver deck)
.su2, .cgns, .msh Mesh generator Meshes (SU2, CGNS, Gmsh)
<case>_NNN/ Solver One run’s folder: run 001, 002, …
input.jsonc Solver The input the run read, exactly as used
wake.status.json Solver The run’s status, start and finish time, solver version and build
*.csv Solver Convergence and monitor histories (residuals, forces, CFL)
*.vtu Solver Volume, surface, and slice results for ParaView
restart_flow_<iteration>.wsol Solver Restart data for continuing a run
<case>_NNN.out, .log Solver The run’s console output and detailed log

Starting Wake CFD components from the command line

Component Command
Wake CFD Desktop wake-cfd-desktop
Solver wake_<2\|3>d_<precision> <case>.jsonc [options]
Mesh check wake_grid <mesh file> --metric (quality), --bc (zones and markers)
License wake_lic

Common solver options:

Option Effect
--validate Check the case and exit, without running (--format json for scripts)
--iter N Run N iterations, overriding the case
--restart <run folder \| file.wsol> Continue a previous run from its latest (or the given) restart file
--overlay <file>, --patch <file> Apply changes to the case for this run only (parameter studies)
--device N Use GPU N
--capabilities Print what this executable supports (dimension, precision, device)
-h, --help List every option

For parallel runs, start the solver through MPI, for example mpirun -np 4 wake_3d_mixed case.jsonc. See the CLI guide.

How to use this manual

If you need to… Read…
Install Wake CFD and complete a first run 1. Getting started
See what the solvers and models support 2. Capabilities
Use Wake CFD Desktop or the CLI 3. How to use Wake CFD
Learn from a guided engineering case 4. Tutorials
Choose recommended settings or diagnose a run 5. Best practices
Define mesh, physics, domains, numerics, and outputs 6. Input and configuration
Script cases and runs from Python 7. Python API
Run on Slurm or connect an AI agent 8. Automation and integration

Read the chapters in order for a first installation. Experienced users can use the input chapters as a reference on their own.

Validation and engineering use

Interpret a Wake CFD result together with the mesh, boundary conditions, physical model, numerical settings, convergence history, and solver version that produced it. A run that finishes is not by itself evidence that the result is accurate.

The Wake CFD Validation Reports compare Wake CFD with analytical solutions, published reference computations, and experimental data. For a new engineering case:

  • start from a comparable validated or verified case;
  • change one major setting at a time and keep a baseline result;
  • check conservation and convergence monitors before interpreting field data;
  • record the solver, model, mesh, precision, and version with the result.

Document conventions

  • Settings and command-line arguments appear as code.
  • Quantities are in SI units unless a section states otherwise.
  • Tables summarize supported combinations; the linked reference pages give the full descriptions and restrictions.
  • A limitation or development status is stated where it affects the choice of solver or the interpretation of a result.