FerrumCFD

Rust-native CFD with familiar case workflows and a path from validated CPU solvers to scalable GPU execution.

Comment

Inspiration

Computational fluid dynamics can demand substantial compute time and energy. I started FerrumCFD to explore whether a Rust-native finite-volume platform can keep a familiar case-based engineering workflow while making resource use more explicit and preparing the numerical stack for parallel CPUs and GPUs.

FerrumCFD is submitted by TriCore Engineering UG (haftungsbeschränkt), represented by founder Marten Mehring.

The long-term objective is not a case-specific benchmark. It is a reusable CFD platform where users can choose serial CPU, multi-CPU, single-GPU, multi-GPU, or mixed CPU/GPU execution according to the problem and available hardware.

What it does

FerrumCFD 0.1.0 currently provides a working Rust solver foundation for steady, laminar, incompressible flow:

  • ferrumRun -solver incompressibleFluid -case CASE_DIRECTORY dispatches the solver.
  • Cases use familiar controlDict, fvSchemes, fvSolution, field, and constant/polyMesh files.
  • Gmsh meshes can be imported into the runtime mesh representation.
  • The SIMPLE loop solves momentum and pressure with configurable linear solvers and preconditioners.
  • Residual control distinguishes linear-solver convergence from outer SIMPLE convergence.
  • Reports are written as JSON, Markdown, CSV, and native Rust-rendered SVG.
  • empty, wedge, and symmetryPlane mesh semantics establish the path for 2D, axisymmetric, and symmetric cases.

The repository includes separate analytical and external-reference validation for a circular laminar pipe and a true 2D plane channel. These references stay outside the solver and case semantics.

Interim validation and benchmark snapshot

These are interim single-core CPU results, not final performance claims. Optimization is continuing. Current reports, reproducible measurement details, and benchmark updates are maintained in the FerrumCFD repository.

A fresh release residual-demo run of the 2,000-cell plane-channel tutorial reached configured outer convergence after 545 SIMPLE iterations in 6.17 seconds. Its mean velocity differs from the analytical plane-Poiseuille solution by 0.165 percent.

  • Pipe: FerrumCFD 15.95 s, OpenFOAM 13 8.77 s; analytical errors 0.177% and 0.086%.
  • Plane channel: FerrumCFD 8.16 s, OpenFOAM 13 3.47 s; analytical errors 0.165% and 0.436%.

Both solvers remain below one percent analytical error in these cases. OpenFOAM is currently faster. FerrumCFD is closer to the analytical result for the plane channel. The OpenFOAM channel row is a fixed-budget result and did not meet the complete outer residual criterion; the repository documents that convergence detail and the full measurement contract.

Under the documented fixed-work measurement contract, the optimized implementation is 29.13x faster for the 10-iteration pipe case and 139.55x faster for the 500-iteration channel case than FerrumCFD's original recorded baselines. Compilation time is excluded, release binaries are used, and numerical behavior is checked before an optimization is accepted.

FerrumCFD is still an early solver and does not yet claim to be a complete or generally faster replacement for established CFD packages. The current work shows a validated solver foundation and a measured path toward that goal.

For judging and reproduction:

How Codex and GPT-5.6 were used

I defined the physical scope, workflow compatibility, performance objective, and acceptance rules. During OpenAI Build Week, Codex with GPT-5.6 inspected and profiled the Rust implementation, proposed bounded technical changes, and implemented the accepted optimizations.

This included reusable CSR topology, cached mesh geometry, reusable pressure matrices and workspaces, PCG/IC(0) and GAMG work, native SVG residual plotting, regression tests, and measurement documentation. The repository records the model timeline, division of responsibilities, dated commits, measurement contract, and results in docs/build-week-2026.md. Codex Security was used independently to review the repository and focused changes.

Challenges and lessons

Rust does not make numerical software fast automatically. The largest gains came from solver algorithms, sparse-matrix reuse, memory layout, avoiding repeated geometry work, and measuring prebuilt release binaries. The difficult part was improving those paths without silently changing equations, convergence criteria, or floating-point ordering.

What's next

This laminar incompressible SIMPLE implementation is the first of many planned FerrumCFD solvers. The roadmap moves from the serial CPU reference backend to threaded and distributed CPU execution, then single- and multi-GPU kernels under the same operator and convergence contracts.

Solver capability will expand to transient and turbulent flow, heat transfer, species transport, and coupled multi-region cases.

Built With

  • codex
  • github-actions
  • gmsh
  • gpt-5.6
  • rust
Share this project:

Updates