ZenteiQ
All blog posts Scientific ML

ScireX: an open-source JAX library and reproducible benchmark for neural operators

Reliable scientific AI starts with a practical question: which neural operator works best for a given engineering problem? With ScireX, our open-source JAX library, we train four leading architectures on the same published data, at the same model size and through one shared pipeline, with results regenerable from released checkpoints. Here we show where each architecture excels, how well it predicts over time, what it costs to train, and how a model can learn from the physics alone.

ZenteiQ Research9 min read

Why ScireX?

From hours of simulation to seconds of prediction

Simulation-driven engineering, from design exploration and optimization to uncertainty quantification, requires solving the same governing equations many times for different coefficients, boundary conditions and geometries. ScireX addresses this with operator learning. Instead of fitting a single solution, a neural operator learns the map from a PDE's inputs (coefficients, boundary conditions, geometry) to its solution field. Once trained, it predicts any new instance of that PDE in a single forward pass, without retraining. ScireX brings four neural-operator architectures, FNO, WNO, GINO and Transolver, under one common API in JAX. The same code runs on CPU, GPU and Cloud TPU, and the architectures are compared side by side on benchmarks spanning porous-media flow, fluid dynamics, heat transfer and aerodynamics. Released checkpoints let anyone reproduce the reported results. Physics-informed losses train a model from the governing equations alone, with no labeled solutions. However, the aim is not to replace FEM or CFD solvers but to learn from them and complement them: the operator explores the design space in seconds, and the high-fidelity solver confirms the designs that matter.

Full simulation

  • Solves the governing equations from first principles
  • Minutes to hours per configuration
  • The reference for verification

Learned surrogate

  • Learns the input-to-solution map from completed simulations
  • One forward pass per configuration
  • Shortlists candidates for full simulation

Where does a surrogate fit in design work?

In a design workflow, the surrogate acts as an intermediate screening stage. Simulations accumulated from earlier projects, or a single dedicated batch, form the training set. The trained model then evaluates new candidate designs in a single forward pass, and only the most promising few are passed back to the high-fidelity solver for confirmation before any physical prototype is built.

1Collect simulations

Engineers often have many from earlier projects, or run one batch.

2Train the model

It learns how each input, such as a car shape, turns into each result, such as surface pressure.

3Ask about new designs

The model predicts the result for a design it has never seen, in one forward pass.

4Confirm the best

The most promising few are checked with the full simulation before anything is built.

What is in the ScireX library?

ScireX is an open-source JAX framework for scientific machine learning, built for researchers and engineers who need a robust, efficient and mathematically rigorous platform. At its core are neural operators, which learn the solution operators of parametric partial differential equations. A neural operator approximates a mapping \(\mathcal{G}:\mathcal{A}\to\mathcal{U}\) between function spaces, where \(\mathcal{A}\) is the space of input functions (such as coefficient fields, boundary conditions or geometries), \(\mathcal{U}\) is the space of solution fields, and \(\mathcal{G}\) is the solution operator that maps each input to its solution. Examples include the map from a permeability field to the pressure field in Darcy flow, and from a vehicle's surface geometry to its surface pressure distribution. Because the operator is parametrized on functions rather than on a fixed discretization, its accuracy depends only weakly on the resolution of the training mesh.

FNO

Fourier neural operator

Core idea
Learns in Fourier space on a regular grid, keeping the low-frequency modes
Start here if
Your data is on a regular grid with smooth fields. Fastest to train

WNO

Wavelet neural operator

Core idea
Learns on wavelet coefficients, localized in both space and scale
Start here if
Your grid data has sharp or multi-scale local features

GINO

Geometry-informed neural operator

Core idea
A graph kernel maps an irregular mesh onto a latent grid, an FNO works there, and a second graph kernel maps back
Start here if
You have arbitrary geometry or 3D meshes

Transolver

Transformer solver with physics attention

Core idea
Attention between a small set of learned "slices" of the mesh, so cost grows linearly with the number of points
Start here if
You have a large unstructured mesh

Experimental models, such as the graph-wavelet hybrid GIWO, live in scirex.experimental until they meet the same bar. available_models() lists every architecture in the version you have installed.

No solution labels, or only a few? Any of these models can be trained with a physics loss, directly on the equation (see pure physics implementation).

Common API

Every model shares one init/apply interface, one registry, one typed configuration system and one checkpoint format.

Physics built in

Data losses, physics-residual losses with finite-element loss on Q4 elements, and Gmsh mesh generation.

JAX-powered: from CPUs to GPUs and TPUs

Built natively in JAX: jit compiles for any device, vmap batches ensembles, and grad gives derivatives for physics losses and inverse design.

Example: define a Fourier neural operator, initialize its parameters and run a forward pass on a batch of 64 × 64 input fields.

import jax, jax.numpy as jnp
from scirex.models import FNO

model = FNO(n_modes=(16, 16), hidden_channels=64, n_layers=4,
            in_channels=1, out_channels=1)
x = jnp.ones((4, 1, 64, 64))                    # batch of 64x64 fields
params = model.init(jax.random.PRNGKey(0), x)
y = model.apply(params, x)                      # (4, 1, 64, 64)
The mathematics of each model family

Let \(\mathcal{G}:\mathcal{A}\to\mathcal{U}\) be the solution operator, mapping an input function \(a\in\mathcal{A}\) to the corresponding solution \(u\in\mathcal{U}\). Given samples \(\{(a_i,u_i)\}_{i=1}^N\), the models minimize the empirical relative error

$$\mathcal{L}(\theta)=\frac1N\sum_{i=1}^N \frac{\lVert \mathcal{G}_\theta(a_i)-u_i\rVert_2}{\lVert u_i\rVert_2}.$$

Kernel-integral models stack layers \(v_{t+1}(x)=\sigma\big(Wv_t(x)+(\mathcal{K}_t v_t)(x)\big)\) between a lifting \(\mathcal{P}\) and a projection \(\mathcal{Q}\); the parametrization of \(\mathcal{K}_t\) defines each family.

FNO
\((\mathcal{K}v)(x)=\sum_{k\in M} R(k)\,\hat v(k)\,e^{2\pi i k\cdot x}\), with complex weights \(R(k)\in\mathbb{C}^{d_v\times d_v}\) on a truncated mode set \(M\); optional Tucker factorization.
WNO
\(\mathcal{K}v=\mathcal{W}_m^{-1}\big(R_A\odot c_A,\,R_D\odot c_D^{(m)},0,\dots,0\big)\): per-position channel mixing on the coarsest approximation and detail sub-bands of an \(m\)-level Daubechies transform.
GINO (and the experimental GIWO)
\((\mathcal{K}_{\rm GNO}f)(x)=\bigoplus_{y\in N_r(x)}\kappa_\theta(\gamma(y),\gamma(x))\,f(y)\) maps the mesh onto a latent grid; an FNO (GINO) or WNO (GIWO) acts on the grid; a second graph kernel maps to the query points.
Transolver
Slice weights \(S=\mathrm{softmax}_G((zW_s+b_s)/\tau)\in\mathbb{R}^{N\times G}\), tokens \(T=S^\top f/(S^\top\mathbf{1}+\epsilon)\), attention among the \(G\) tokens and deslicing \(\hat x=S\hat T\), at cost \(O(NGC+G^2C)\).

How did we test it?

We evaluate on published data rather than on problems of our own design. The nine benchmark problems are derived from eight simulation datasets released by independent research groups, and together they cover porous media, internal and external flow, heat transfer and vehicle aerodynamics. Each problem inherits a published reference result, so every number reported here can be independently compared with prior work. A single, shared pipeline is applied to all nine.

1Load benchmark data

The source study's split, normalized as each model's reference code does.

2Match model size

Every model gets the same parameter budget, normally within a few percent.

3Optimize hyperparameters

Architecture-specific hyperparameters are tuned within the matched parameter budget.

4Report final checkpoints

Final trained weights are evaluated; no checkpoint is chosen by test error.

5Regenerate numbers

An inference script reloads the checkpoint and rewrites every metric and figure.

Parameter counts of every reported run
Complex weights count as two real parameters. The reference budget for each problem is marked *.
ProblemFNOWNOGINOTransolverGIWO
Darcy2,836,2812,829,6012,801,3402,826,945*–
Pipe2,999,6293,102,1573,001,9563,073,985*–
Navier–Stokes11,183,46711,312,95711,297,04111,232,321*–
Cavity1,056,739*1,042,0731,058,8611,093,851–
Chip cooling1,829,4961,920,4811,821,0281,807,561*–
AirfRANS–3,964,7283,894,0693,894,596*–
ShapeNetCar––3,852,4943,860,804*3,752,638
Car-CFD––75,917,953*75,481,84174,197,232

All counts are within 3.6% of the reference model except the chip-cooling WNO (+6.2%). Where a recipe is shared (Pipe, Navier–Stokes) it is the Transolver paper's. Published baselines are quoted from the papers; for Pipe we also ran the official PyTorch Transolver code.

What did we find?

Transolver is the most consistent winner, most accurate on six of the nine problems. No single model is best everywhere: FNO is clearly best on chip cooling and the fastest to train, and GINO is best on Navier–Stokes and stays accurate for longest when predicting many steps ahead.

Headline results on held-out test data. Our result is the test error of the most accurate of the four models on each problem, trained at matched parameter count. Published reference is the best prior result on the same dataset. Rel. L2 is the relative L2 error of the predicted field; RMSE and MAE are absolute errors in physical units. Lower is better.
ProblemTaskMetricBest modelOur resultPublished reference
Darcy flowporous-medium permeability → pressureRel. L2Transolver0.532%0.57% (Transolver)
Darcy flow, physics-onlysame, trained without solutionsRel. L2Transolver0.565%0.57% (Transolver, with 1,000 solutions)
Pipe flowpipe shape → velocityRel. L2Transolver0.386%0.33% (Transolver)
Navier–Stokes 2D10-step vorticity rolloutRel. L2GINO6.66%9.00% (Transolver)
Lid-driven cavitynext frame, unseen Reynolds numberRMSEGINO1.95×10⁻³ m/s6.43×10⁻³ m/s (FNO)
Chip cooling6 operating settings → temperatureMAEFNO0.12 K1.53 K (POD-NN)
AirfRANSairfoil → flow field and liftRel. L2Transolver2.65%10.3% (Transolver)
ShapeNetCarcar → velocity, pressure, dragRel. L2Transolver7.67%7.45% (Transolver)
Car-CFDcar → surface pressureRel. L2Transolver6.81%7.12% (GINO)

Highlighted: better than the published reference. Where a published Transolver figure exists, our implementation matches or improves on it for Darcy, Navier–Stokes and AirfRANS, and comes close on ShapeNetCar (7.67% against 7.45% for surface pressure, 1.06% against 1.03% for drag).

See the predictions

Choose a benchmark. Each view shows the model's prediction, the full simulation and the difference between them; a dark difference panel means small errors. Step through with the arrows or the slider, or press play for a slow tour.

Full results for every model
Final-epoch weights. The experimental GIWO is benchmarked separately in the documentation.
Problem (metric)FNOWNOGINOTransolverPublished
Darcy (rel. \(L^2\), %)1.1092.021.600.532T 0.57; W ≈0.84; F 1.08
Pipe (rel. \(L^2\), %)0.9340.5291.0240.386T 0.33
Navier–Stokes (rollout, %)7.0531.986.668.72T 9.00; copy-last 74.81
Cavity, 1 step (10⁻³ m/s)1.972.041.952.04F 6.43
Cavity, 10 steps (10⁻³ m/s)6.316.042.807.66F 8.79 (3 in, 3 out)
Chip cooling (MAE, K)0.1220.6400.4250.665POD-NN 1.534
AirfRANS (volume, ×10⁻³)–4.4625.41.31T 3.7; GINO 29.7
AirfRANS (\(C_L\) error, %)–2.977.522.65T 10.30
ShapeNetCar (surface, %)––21.497.67T 7.45
ShapeNetCar (\(C_D\) error, %)––7.791.06T 1.03
Car-CFD (rel. \(L^2\), %)––8.376.81GINO 7.12

Three qualifications apply. The AirfRANS improvement comes mainly from additions to the official recipe (log wall-distance and \(\log\mathrm{Re}\) inputs, inflow-scaled targets, weight EMA with spike clipping, 500 instead of 398 epochs, and FP32 matrix multiplication); the official recipe alone gives a volume error of \(40.5\times10^{-3}\). The published AirfRANS surface value may be the wall-pressure MSE alone, so that comparison is uncertain. The cavity FNO includes a point-wise MLP per block that the reference lacks, so its 3.3-fold improvement over the published FNO is partly architectural.

On the large 3D problems, the graph-kernel models trail Transolver; on Car-CFD our GINO fits the training data far better than reported (3.55% against 6.37%) but generalizes worse (8.37% against 7.12%).

Can a model learn without labeled solutions?

Usually a model needs many worked examples, each with the correct answer attached. In engineering, every correct answer costs a simulation run, which is exactly the expense a surrogate is meant to avoid.

For water seeping through an underground porous medium (Darcy flow), we gave the model no labeled solutions, only the rule nature follows: the water settles into the arrangement with the least energy. The model taught itself by searching for that arrangement, using porous-medium samples that cost nothing to generate.

Trained on pure physics governing equations

Label-free Transolver on unseen porous-medium samples. The model never saw a correct pressure field during training.

With 10,000 unlabeled porous-medium samples, Transolver reaches 0.565% error, level with the best published model trained on 1,000 solved examples (0.57%) and close to our own labeled Transolver (0.532%).

The Ritz-energy formulation

The Darcy problem \(-\nabla\cdot(a\nabla u)=1\) on \((0,1)^2\), \(u|_{\partial\Omega}=0\), \(a\in\{3,12\}\), has the weak solution that minimizes

$$J_a(u)=\tfrac12\int_\Omega a\,|\nabla u|^2\,\mathrm{d}x-\int_\Omega u\,\mathrm{d}x \quad\text{over } H^1_0(\Omega).$$

We train on \(\mathbb{E}_a\,J_a^h(u_\theta(a))\), with \(J^h\) discretized by bilinear Q4 elements on the \(85\times85\) nodes (\(2\times2\) Gauss points; majority-vote element coefficients; FP32 finite-element arithmetic, since TF32 perturbs the Q4 Jacobians by up to 5%). The boundary condition is exact through \(u_\theta(a)=(c\,N_\theta(a)+m)\sin(\pi x)\sin(\pi y)\), with \(c,m\) from the Q4 torsion function scaled by \(1/\sqrt{3\cdot12}\). An exact Q4 solve gives a formulation floor of 0.31% (0.12% on the native \(420\times420\) mesh). Unlabeled fields come from the coefficient law \(a=\psi_\#\mathcal{N}(0,(-\Delta+9I)^{-2})\). For FNO and WNO the energy is scaled by the 6,889 interior nodes, because otherwise most gradient entries at initialization fall below Adam's \(\epsilon\).

Label-free Darcy: test relative \(L^2\) error (%) against the number of unlabeled fields (final model).
Fields1,0002,0005,00010,00020,000With 1,000 labels
Transolver1.0200.7760.6340.5650.6150.556
FNO1.2110.9620.8290.6480.6601.109
GINO1.1560.8200.7360.7550.7221.603
WNO2.7691.8951.3791.3081.2622.020

Can a single step predict ten steps ahead?

When a model steps forward in time, each prediction becomes the input for the next, so small errors can grow. In the lid-driven cavity, all four models start within 5% of each other at one step. After ten steps, GINO's error has grown only 1.4-fold, against 3.0–3.8-fold for the others.

Lid-driven cavity at an unseen Reynolds number

Velocity error (10⁻³ m/s) after one step and after a ten-step rollout. Lower is better.

After 1 stepAfter 10 steps

Navier–Stokes shows the same effect. Transolver is the most accurate on the first predicted frame (1.1% against about 2% for FNO and GINO), but its error grows faster, so by the fourth frame FNO and GINO are ahead, and they finish the ten-step rollout at 6.7–7.1% against 8.7%.

If a surrogate will be used for time stepping, test it on multi-step rollouts, not only on the next frame.

What does training cost?

At the same number of parameters, training cost differs by more than an order of magnitude. The cost is not in the weights: two GINO sizes 20 times apart in parameters cost almost the same per epoch. Graph-kernel models pay for the small network evaluated on every neighbor edge, and WNO pays for sequential wavelet filter banks.

Total training time at matched model size

Hardware: all benchmarks were trained on an NVIDIA RTX PRO 6000 Blackwell Max-Q Workstation Edition GPU, except the lid-driven cavity, which was trained on an NVIDIA DGX Spark (GB10 Grace Blackwell).

FNO is the cheapest on four of the five problems it runs on; WNO is quicker on Pipe. On the 3D car problems, which only GINO and Transolver run, the two are within a factor of two of each other. When budgeting a surrogate project, measure the cost per epoch on your own data rather than inferring it from model size.

Target audience

Engineering and R&D teams

In automotive, aerospace, energy and electronics, turning expensive simulation workflows into fast, reliable surrogates that accelerate design exploration.

Researchers and ML developers

Building and comparing neural operators on fair, reproducible benchmarks, with both data-driven and physics-informed training.

Students and educators

Learning where machine learning, numerical simulation and physics meet, through open-source code, real datasets and worked examples.

How do I use ScireX?

Each benchmark is a self-contained package with its configuration, data loader, training and inference scripts, so adding your own problem means writing those files, without changing the library. It runs on Python 3.10–3.12, on CPU, NVIDIA GPUs (CUDA 12) and Cloud TPUs.

pip install scirex                 # CPU
pip install "scirex[cuda]"         # NVIDIA GPU (CUDA 12)

# reproduce a benchmark from source
git clone https://github.com/zenteiq-sciml/scirex
cd scirex && pip install -e ".[cuda]"
python scripts/benchmarks/darcy/train.py --run transolver
python scripts/benchmarks/darcy/infer.py   # writes metrics.json and figures

For a step-by-step walkthrough of applying ScireX to your own data, from choosing a model and saving your data to training and prediction, see the Usage guide in the ScireX documentation.

ScireXOpen-source neural operators in JAX by ZenteiQ, LGPL-3.0

References

  1. Z. Li et al. Fourier neural operator for parametric partial differential equations. ICLR, 2021.
  2. N. Kovachki et al. Neural operator: learning maps between function spaces with applications to PDEs. JMLR 24, 2023.
  3. T. Tripura, S. Chakraborty. Wavelet neural operator for solving parametric partial differential equations in computational mechanics problems. CMAME 404, 2023.
  4. Z. Li et al. Geometry-informed neural operator for large-scale 3D PDEs. NeurIPS, 2023.
  5. Z. Li, D. Z. Huang, B. Liu, A. Anandkumar. Fourier neural operator with learned deformations for PDEs on general geometries. JMLR 24, 2023.
  6. H. Wu, H. Luo, H. Wang, J. Wang, M. Long. Transolver: a fast transformer solver for PDEs on general geometries. ICML, 2024.
  7. J. Kossaifi et al. A library for learning neural operators. arXiv, 2024.
  8. F. Bonnet, A. J. Mazari, P. Cinnella, P. Gallinari. AirfRANS: high fidelity CFD dataset for approximating RANS solutions. NeurIPS Datasets and Benchmarks, 2022.
  9. N. Umetani, B. Bickel. Learning three-dimensional flow for interactive aerodynamic design. ACM TOG 37(4), 2018.
  10. P. A. Costa Rocha et al. Deep neural network modeling for CFD simulations: benchmarking the Fourier neural operator on the lid-driven cavity case. Applied Sciences 13(5), 2023.
  11. D. Curl, H. Hu. Physically interpretable surrogate modeling of thermal fields in electronics cooling using combined POD and neural networks. AI in Thermal Fluids 6, 2026.

The simulation datasets belong to their authors: Li et al. (Darcy, Navier–Stokes, pipe), Costa Rocha et al. (cavity), Curl and Hu (chip cooling), Bonnet et al. (AirfRANS), Umetani and Bickel (ShapeNetCar, Car-CFD). Reference implementations: neuraloperator and the official Transolver code.

Discuss the science behind our models

Technical architecture, evaluation approach and benchmark materials, shared with qualified partners under NDA.