Overview of Wake CFD
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.
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.
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
- Install Wake CFD.
- Run the packaged ONERA M6 half-wing example: the ONERA M6 quickstart uses the Desktop and shows the command-line run as well.
- 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.jsoncNames
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.