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.
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.
Engineers often have many from earlier projects, or run one batch.
It learns how each input, such as a car shape, turns into each result, such as surface pressure.
The model predicts the result for a design it has never seen, in one forward pass.
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).
Every model shares one init/apply interface, one registry, one typed configuration system and one checkpoint format.
Data losses, physics-residual losses with finite-element loss on Q4 elements, and Gmsh mesh generation.
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
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.
The source study's split, normalized as each model's reference code does.
Every model gets the same parameter budget, normally within a few percent.
Architecture-specific hyperparameters are tuned within the matched parameter budget.
Final trained weights are evaluated; no checkpoint is chosen by test error.
An inference script reloads the checkpoint and rewrites every metric and figure.
Parameter counts of every reported run
| Problem | FNO | WNO | GINO | Transolver | GIWO |
|---|---|---|---|---|---|
| Darcy | 2,836,281 | 2,829,601 | 2,801,340 | 2,826,945* | – |
| Pipe | 2,999,629 | 3,102,157 | 3,001,956 | 3,073,985* | – |
| Navier–Stokes | 11,183,467 | 11,312,957 | 11,297,041 | 11,232,321* | – |
| Cavity | 1,056,739* | 1,042,073 | 1,058,861 | 1,093,851 | – |
| Chip cooling | 1,829,496 | 1,920,481 | 1,821,028 | 1,807,561* | – |
| AirfRANS | – | 3,964,728 | 3,894,069 | 3,894,596* | – |
| ShapeNetCar | – | – | 3,852,494 | 3,860,804* | 3,752,638 |
| Car-CFD | – | – | 75,917,953* | 75,481,841 | 74,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.
| Problem | Task | Metric | Best model | Our result | Published reference |
|---|---|---|---|---|---|
| Darcy flow | porous-medium permeability → pressure | Rel. L2 | Transolver | 0.532% | 0.57% (Transolver) |
| Darcy flow, physics-only | same, trained without solutions | Rel. L2 | Transolver | 0.565% | 0.57% (Transolver, with 1,000 solutions) |
| Pipe flow | pipe shape → velocity | Rel. L2 | Transolver | 0.386% | 0.33% (Transolver) |
| Navier–Stokes 2D | 10-step vorticity rollout | Rel. L2 | GINO | 6.66% | 9.00% (Transolver) |
| Lid-driven cavity | next frame, unseen Reynolds number | RMSE | GINO | 1.95×10⁻³ m/s | 6.43×10⁻³ m/s (FNO) |
| Chip cooling | 6 operating settings → temperature | MAE | FNO | 0.12 K | 1.53 K (POD-NN) |
| AirfRANS | airfoil → flow field and lift | Rel. L2 | Transolver | 2.65% | 10.3% (Transolver) |
| ShapeNetCar | car → velocity, pressure, drag | Rel. L2 | Transolver | 7.67% | 7.45% (Transolver) |
| Car-CFD | car → surface pressure | Rel. L2 | Transolver | 6.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
| Problem (metric) | FNO | WNO | GINO | Transolver | Published |
|---|---|---|---|---|---|
| Darcy (rel. \(L^2\), %) | 1.109 | 2.02 | 1.60 | 0.532 | T 0.57; W ≈0.84; F 1.08 |
| Pipe (rel. \(L^2\), %) | 0.934 | 0.529 | 1.024 | 0.386 | T 0.33 |
| Navier–Stokes (rollout, %) | 7.05 | 31.98 | 6.66 | 8.72 | T 9.00; copy-last 74.81 |
| Cavity, 1 step (10⁻³ m/s) | 1.97 | 2.04 | 1.95 | 2.04 | F 6.43 |
| Cavity, 10 steps (10⁻³ m/s) | 6.31 | 6.04 | 2.80 | 7.66 | F 8.79 (3 in, 3 out) |
| Chip cooling (MAE, K) | 0.122 | 0.640 | 0.425 | 0.665 | POD-NN 1.534 |
| AirfRANS (volume, ×10⁻³) | – | 4.46 | 25.4 | 1.31 | T 3.7; GINO 29.7 |
| AirfRANS (\(C_L\) error, %) | – | 2.97 | 7.52 | 2.65 | T 10.30 |
| ShapeNetCar (surface, %) | – | – | 21.49 | 7.67 | T 7.45 |
| ShapeNetCar (\(C_D\) error, %) | – | – | 7.79 | 1.06 | T 1.03 |
| Car-CFD (rel. \(L^2\), %) | – | – | 8.37 | 6.81 | GINO 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
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\).
| Fields | 1,000 | 2,000 | 5,000 | 10,000 | 20,000 | With 1,000 labels |
|---|---|---|---|---|---|---|
| Transolver | 1.020 | 0.776 | 0.634 | 0.565 | 0.615 | 0.556 |
| FNO | 1.211 | 0.962 | 0.829 | 0.648 | 0.660 | 1.109 |
| GINO | 1.156 | 0.820 | 0.736 | 0.755 | 0.722 | 1.603 |
| WNO | 2.769 | 1.895 | 1.379 | 1.308 | 1.262 | 2.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.
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
In automotive, aerospace, energy and electronics, turning expensive simulation workflows into fast, reliable surrogates that accelerate design exploration.
Building and comparing neural operators on fair, reproducible benchmarks, with both data-driven and physics-informed training.
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.
References
- Z. Li et al. Fourier neural operator for parametric partial differential equations. ICLR, 2021.
- N. Kovachki et al. Neural operator: learning maps between function spaces with applications to PDEs. JMLR 24, 2023.
- T. Tripura, S. Chakraborty. Wavelet neural operator for solving parametric partial differential equations in computational mechanics problems. CMAME 404, 2023.
- Z. Li et al. Geometry-informed neural operator for large-scale 3D PDEs. NeurIPS, 2023.
- Z. Li, D. Z. Huang, B. Liu, A. Anandkumar. Fourier neural operator with learned deformations for PDEs on general geometries. JMLR 24, 2023.
- H. Wu, H. Luo, H. Wang, J. Wang, M. Long. Transolver: a fast transformer solver for PDEs on general geometries. ICML, 2024.
- J. Kossaifi et al. A library for learning neural operators. arXiv, 2024.
- F. Bonnet, A. J. Mazari, P. Cinnella, P. Gallinari. AirfRANS: high fidelity CFD dataset for approximating RANS solutions. NeurIPS Datasets and Benchmarks, 2022.
- N. Umetani, B. Bickel. Learning three-dimensional flow for interactive aerodynamic design. ACM TOG 37(4), 2018.
- 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.
- 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.