Physics-Informed Neural Networks in 2026: A Full-Stack Guide from Principles and Failure Boundaries to Engineering Selection

New
License: Original (DClaw) · Updated 2026-11-08
My rating

Why This Guide

Physics-informed neural networks (PINNs) are among the most cited ideas in scientific machine learning, and among the most frequently misapplied. Since Raissi, Perdikaris and Karniadakis published the framework in 2019, the literature has grown to thousands of papers, a handful of mature libraries, and a much smaller number of credible industrial deployments. The gap between the size of the literature and the size of the deployed footprint is itself the most useful signal for a practitioner. A method can be theoretically elegant, easy to implement in thirty lines of PyTorch, and still be the wrong tool for a given engineering task.

This guide is written as a decision document rather than a tutorial. It does not assume you want to use a PINN. It assumes you have a physical problem, a compute budget, some amount of data or the possibility of generating it, and a requirement to produce a defensible answer. The central claim is that PINNs, neural operators, differentiable solvers and classical numerical solvers address different contracts, and that most reported disappointment with PINNs comes from a contract mismatch rather than from an implementation defect. Once the contract is stated explicitly, the choice of method becomes close to mechanical.

The guide is organised in ten sections. Sections 1 to 3 establish the mathematical mechanics and the division of labour between paradigms. Sections 4 and 5 explain why PINN training fails and what the 2026 literature does about it. Sections 6 to 8 give a selection tree, a toolchain map and an engineering checklist. Section 9 links this review to the concrete resources indexed on this site, so a reader can move from a general argument to a specific solver, benchmark or case. Section 10 records the public claims that conflict with each other and states how this guide rules on each one.

A note on evidence. Where a number is cited, its provenance is stated. Benchmark figures drawn from a single project's equal-compute study are labelled as directional, not as general laws. Claims from vendor documentation are labelled as such. This matters because the PINN literature contains a large amount of self-reported improvement measured on a small set of canonical equations, and transferring those numbers to an industrial CFD or structural problem is rarely justified.

1. What a PINN Actually Optimises

Consider a partial differential equation written in residual form, with a differential operator acting on an unknown field, together with initial conditions, boundary conditions and possibly a set of sparse observations. A PINN replaces the unknown field with a neural network that takes coordinates as input and returns the field value. Derivatives of the network output with respect to its inputs are computed by automatic differentiation and substituted into the governing equation, so the residual can be evaluated at arbitrary collocation points without any mesh.

The training objective is a weighted sum of several terms: the squared PDE residual over collocation points, the squared mismatch at boundary and initial points, and the squared mismatch against any available measurements. This composite loss is the defining feature of the method and also the source of nearly all its difficulties. Each term is a different mathematical object. Boundary and initial conditions are pointwise constraints on function values. The PDE residual is a differential operator evaluated across a continuum. Data terms are noisy samples of an unknown process. Summing them with scalar weights assumes their gradients are compatible in direction and comparable in magnitude, an assumption that is frequently false.

Two design consequences follow. First, boundary conditions are enforced softly. A network can reach a low average loss while still violating a boundary condition in a localised region, because the penalty is averaged over sample points. Second, the residual is evaluated in strong form, so the network must be differentiated as many times as the equation requires. Higher-order derivatives amplify high-frequency noise and make the loss landscape stiff. Variational, weak-form and integral residuals are the standard remedy, because they align the objective with Galerkin or finite-element reasoning and lower the derivative order.

The practical appeal of this construction is that it needs no labelled solution field. The governing equation supplies the supervision. That makes PINNs attractive for inverse problems, for data assimilation, and for settings where a high-fidelity simulator is unavailable but the governing law is known. It also makes them appear attractive for ordinary forward problems, which is where the mismatch usually begins: for a single forward instance with an available solver, a discretised solve is exact to its discretisation and typically finishes before a network has finished training.

2. Three Paradigms, Three Different Contracts

It is common to see PINNs and neural operators placed on a single leaderboard. The comparison is ill-posed because the two methods optimise different objects and are paid back on different clocks.

A PINN solves one instance. It fits one geometry, one set of boundary conditions, one coefficient field. Change any of these and the network is retrained. Its cost is per instance, its supervision comes from the equation, and its natural tasks are inverse problems, parameter identification and data fusion where a single case is all that exists.

A neural operator learns a mapping between function spaces. It is trained on a database of solutions generated by a solver or by experiment, and once trained it maps a new initial condition, coefficient field or forcing to a solution field in a single forward pass. Fourier Neural Operator (FNO) parameterises the integral kernel in Fourier space and is efficient on structured grids, with a degree of resolution transfer. DeepONet uses a branch and trunk architecture that separately encodes the input function and the query location, which suits irregular geometries and sparsely sampled inputs. Graph and mesh operators generalise mixing to unstructured discretisations. The cost of an operator is amortised across queries, so it becomes economical when the same family of problems must be evaluated many times, as in design optimisation, uncertainty quantification or real-time control.

A third route, increasingly visible in industrial work, is the differentiable solver. Here the conventional discretisation is kept and made differentiable, and the network is used to learn only the unmodelled part, such as a Reynolds-averaged turbulence closure or a subgrid-scale model. Conservation and numerical stability remain with the solver. This sidesteps the weaknesses of pure PINNs in conservation and at high Reynolds number, and it is the hybrid line with the shortest path to deployment.

A fourth baseline must always be present: the classical solver itself. Finite volume, finite element, spectral and lattice-Boltzmann codes are mature, conservative and predictable. Any learned method should be compared against this baseline on wall-clock time to a specified accuracy, with the cost of generating training data counted on the learned side. Comparisons that report operator inference time against PINN training time measure two different clocks and support no architectural conclusion.

The 2026 unifying survey of PDE solvers formalises this as a contract view. Five recurring axes determine which method is appropriate: how much the instance varies, whether geometry and discretisation change, the temporal horizon, what supervision is available, and what validity signals exist at deployment. This framing explains why PINN research concentrates on numerical conditioning and stiff multi-objective training, while operator research concentrates on distribution shift, discretisation mismatch and geometric generalisation. It also predicts where each paradigm fails without warning.

3. Five Failure Modes and Their Mechanisms

The baseline composite-loss PINN has a small, well-characterised set of canonical failures. Recognising the symptom is usually enough to pick the right intervention.

Convergence-rate imbalance. Neural tangent kernel analysis shows that the eigenvalues associated with the residual term can be orders of magnitude larger than those associated with boundary and initial terms. Gradient descent prioritises the large-eigenvalue directions, so the network drives the residual down while effectively ignoring the boundary conditions that make the solution unique. On a high-frequency 1D Poisson problem, a standard PINN was reported at roughly 24 percent relative L2 error, reduced to about 0.16 percent with NTK-based adaptive weighting; on a 1D wave equation the corresponding figures were above 40 percent and about 0.17 percent. Dynamic loss balancing, learning-rate annealing and ReLoBRaLo-style relative loss balancing with random lookback are the practical responses.

Spectral bias. Like other neural networks, PINNs learn low-frequency content first. Boundary layers, sharp interfaces and high-wavenumber structure are delayed, smeared or aliased. Strong-form residual supervision amplifies the problem because differentiation weights high frequencies. Fourier feature encodings, multi-resolution architectures, adaptive collocation near walls and interfaces, and weak-form residuals all target this failure. Evaluation should report spectral error and localised error near interfaces, not global mean squared error alone.

Causality violation in time-dependent problems. When residual points across the whole time domain are minimised simultaneously, the optimiser can fit late-time residuals before the early-time solution has converged, producing a solution that satisfies the equation at late times in a physically meaningless way. Causal training, which weights the loss by temporal order, and time-marching in segments are the standard fixes. A symptom is an unsteady run that agrees at early times and diverges at late times.

Collapse to a trivial solution. With physics-only supervision, the zero field can be a low-residual solution when the boundary or data term is weak. A 2026 study of finite-volume-informed networks for two-dimensional shallow water equations reported collapse to physically meaningless solutions on rugged loss landscapes, and showed that even 50 to 200 sparse measurements break the degeneracy and substantially improve accuracy. The same pattern appears in data-free RANS closure work, where the network converges to zero flow. Hard boundary conditions, raising the boundary weight, adding data points and continuation from a simpler regime are the responses.

Gradient conflict and magnitude imbalance. Loss terms can point in opposing directions, or differ by orders of magnitude in scale, so a single scalar weight cannot fix both problems. Work published in 2026 argues that the conflict is regime-dependent: directional conflict requires architectural separation, such as per-loss adapters, while magnitude imbalance is adequately handled by scalar reweighting. The same work reports up to a 29-fold improvement on challenging problems such as the Klein-Gordon equation using a diagnostic-first approach. A complementary line frames update-direction selection as a Chebyshev centre problem in the dual cone, unifying several existing balancing methods and giving convergence guarantees.

Two cross-cutting issues sit above these five. Geometry and boundary feasibility can be violated silently: an averaged loss may look healthy while constraints are broken in a way that only surfaces when the domain shape changes. And trustworthiness under contract shift is a system property, requiring calibration, out-of-distribution detection, constraint-violation rates and a fallback to a solver, rather than a property of the network alone.

4. The 2026 Frontier: Diagnosis Before Tuning

The most consequential change in the recent literature is methodological. Earlier work treated loss weighting as a hyperparameter to be tuned. The 2026 literature increasingly treats it as a diagnosis to be made. Before choosing an optimiser or a weight schedule, one asks whether the dominant problem is directional conflict, magnitude imbalance, stiffness of the strong-form residual, under-sampling of localised complexity, or the cost of high-order automatic differentiation. Each diagnosis maps to a different intervention, and applying the wrong one wastes the compute budget.

The interventions fall into five groups, matching the five failure modes. Residual reformulation replaces strong-form objectives with variational, weak or integral forms. Constraint handling moves from soft penalties to hard or semi-hard satisfaction via constraint-satisfying parameterisations, projection or physics-embedded discrete operators. Representation uses Fourier encodings and multiresolution architectures to reduce derivative amplification. Optimisation applies dynamic loss balancing, curvature-aware and preconditioned methods, natural-gradient variants and meta-learned update rules. Sampling treats adaptive collocation as experimental design, including causal and adversarial strategies.

Several other directions are active. Domain decomposition, including extended and adaptive variants, splits a hard problem into subdomains and is the usual response when training collapses at higher Reynolds number or on large geometries. Physics-informed neural operators (PINO) add a PDE-residual term to operator training, reducing data requirements while keeping amortised inference. Bayesian and variational formulations quantify uncertainty in inverse problems under sparse or corrupted observations, with recent work providing posterior-concentration guarantees for elliptic PDEs. Hypernetworks and parameter-conditioned PINNs move toward reuse across instances and form a natural bridge to hybrids. Meanwhile, the definition of a valid result is tightening: a 2026 analysis points out that neural variational methods can be ill-posed at the discrete level, producing non-unique solutions even when the continuous problem is well-posed, which argues for more robust loss formulations rather than more training.

For a practitioner, the useful summary is short. Most PINN failures are now diagnosable, and most diagnoses have a standard intervention. What has not changed is that the interventions add complexity to a method whose original appeal was simplicity. Once a project requires weak-form residuals, hard constraints, Fourier features, adaptive sampling, domain decomposition and a causal schedule, it is worth re-examining whether a differentiable solver or a data-driven operator would have been the shorter path.

5. A Decision Tree: Three Questions First

A compact adoption test, adapted from published engineering guidance, settles most cases before any code is written.

Question one: is the goal to fuse measurements with a known physical law? If yes, a PINN is a candidate. If the goal is a pure forward problem and a solver exists for the equations and geometry, use the solver. Its accuracy is bounded by its discretisation, its cost is predictable, and it does not require a training campaign.

Question two: is the target a smooth field, a laminar-to-transitional regime, or a mean quantity? Instantaneous turbulent fields, shocks, discontinuous coefficients and sharp moving interfaces remain out of reach for plain PINNs. Equal-compute studies report that PINNs barely learn or fail to converge on Darcy flow with jumping coefficients and on RANS airfoil cases, sometimes producing errors no better than predicting zero.

Question three: is there an independent means of validation? A reference solution, an analytical solution, or held-out observations are mandatory. Without one, there is no way to demonstrate credibility, and the project should not start. This is the question most often skipped, and it is the reason many PINN results cannot be transferred.

Beyond these three gates, the decision reduces to amortisation and extrapolation. If many queries will be made over a family of inputs and solver data can be generated, a neural operator pays for itself: published equal-budget work reports operator surrogates reaching tens to hundreds of times the accuracy of a PINN at the same training compute, with data cost repaid after a small number of queries. If there is one case, sparse sensors and a known equation, a PINN or classical calibration through the solver is appropriate. If the geometry changes from query to query without a shared parameterisation, a mesh-based graph operator is the natural fit. If only integral quantities such as lift coefficient or peak stress are needed, a scalar regressor on the shape parameters is simpler and more accurate than a field model.

A caution on extrapolation: a surrogate is bounded by its training range. A PINN or a solver has no training range. Any deployment that will see out-of-distribution parameters, resolutions or geometries needs an explicit out-of-distribution test and a fallback path to the solver.

6. Toolchain and Benchmark Map

The software landscape divides into clear tiers, and choosing the wrong tier is a common source of wasted effort.

Lightweight research libraries. DeepXDE is the standard on-ramp for PINNs and DeepONet, with a high-level API, multi-backend support and research-friendly documentation. It is the fastest way to reproduce a paper result. NeuralPDE.jl brings PINN and operator methods into the Julia SciML ecosystem, which matters when the surrounding workflow is already Julia-based. NeuralOperator is a focused PyTorch library for the FNO family.

Differentiable simulation. JAX-CFD and PhiFlow provide differentiable fluid solvers; NVIDIA Warp and Taichi target GPU-accelerated differentiable kernels and simulation. These are the substrate for hybrid approaches where the solver remains differentiable and the network learns a closure term or a correction.

Platform-scale frameworks. NVIDIA PhysicsNeMo, the open-source successor to Modulus, spans physics-informed networks, FNO and adaptive FNO, graph neural networks on meshes, diffusion and transformer surrogates, and domain blueprints for CFD, structural mechanics, electromagnetics and weather. It is built for multi-GPU and multi-node training and digital-twin deployment. It is also substantial and NVIDIA-GPU-centric, so it is a poor fit for a small PINN that could be written in a few lines of DeepXDE. The rename is a frequent source of confusion: tutorials referring to Modulus still apply conceptually, but the package and imports changed.

Classical baselines. OpenFOAM, SU2, FEniCS, PETSc, Clawpack, Dedalus and LAMMPS remain the reference against which learned methods must be compared. This site indexes each of them, alongside the AI-side libraries, precisely so that a reader can put both sides of the comparison on the same page.

Benchmarks. PDEBench provides a broad set of PDE problems with solver-generated reference data. The Well offers diverse spatiotemporal datasets for physical simulation. A benchmark is only useful if the split, the resolution, the rollout horizon and the error metric are stated; a reported relative L2 error on a single low-resolution Burgers case says little about a turbulent industrial flow.

7. An Engineering Checklist

The following sequence is the minimum reproducible workflow for a PINN project. It is deliberately ordered so that cheap checks come before expensive training.

  1. Nondimensionalise. Rescale variables so that inputs, outputs and residual terms are of order one. A large share of apparent convergence failures are scaling failures.
  2. Write down the contract. State the geometry, boundary and initial conditions, parameter ranges, required accuracy, the solver baseline and the validation data before training.
  3. Establish the baseline first. Run the classical solver and record its wall-clock time and error. This is the number every learned method must beat on a defined metric.
  4. Enforce boundaries by construction where possible. A hard constraint parameterisation removes an entire class of failure and reduces the number of competing loss terms.
  5. Choose the residual form deliberately. Prefer variational or weak forms for stiff or high-order equations.
  6. Instrument every loss component separately. Log residual, boundary, initial and data terms per iteration, and archive the training history. A single total-loss curve hides the pathology.
  7. Start with Adam, then L-BFGS. If the second stage diverges, extend the first stage and revisit the weight balance instead of lowering the learning rate blindly.
  8. Add diagnostics before adapters. Check gradient-direction conflict and magnitude imbalance, and only then decide between reweighting and architectural separation.
  9. Use adaptive or causal sampling when localised structure or long time horizons are present.
  10. Validate against held-out data and invariants. Check conservation, boundary-condition satisfaction, spectral error and long-horizon rollout growth, not only the relative L2 error.
  11. Define the fallback. State the condition under which the solver, rather than the learned model, produces the reported answer.

Troubleshooting maps cleanly onto this list. A field collapsing to a uniform value indicates a trivial solution, fixed by hard boundaries, higher boundary weight or added data. A pressure field that is wrong while velocities look right indicates pressure indeterminacy, fixed by pinning pressure at one point and comparing with the mean removed. Blurred boundary layers indicate spectral bias, fixed by Fourier features and denser near-wall collocation. Sudden collapse at higher Reynolds number indicates insufficient capacity or poor scaling, fixed by nondimensionalisation, domain decomposition or continuation from a lower-Reynolds solution. Inferred parameters that change between runs indicate non-uniqueness from insufficient observations, fixed by better sensor placement, priors and confidence intervals.

8. Evaluation Beyond Relative L2 Error

A single global error number is a poor basis for claiming that a physics-informed model is trustworthy. The 2026 contract view argues for metrics aligned with the deployment signal: spectral error to expose frequency-dependent bias, localised error near interfaces and boundaries, rollout error growth over long horizons, and task-level invariants such as conservation of mass, momentum or energy. Constraint-violation rates should be reported explicitly, because a soft penalty can leave a small region badly violated while the average looks excellent.

Two further checks matter in practice. The first is an out-of-distribution row: evaluate on parameters, geometries, resolutions and rollout horizons outside the training set and report the degradation. A method that is strong in interpolation and collapses under a modest shift is not deployable. The second is an amortisation calculation: count the cost of generating training data and of training, then compute the number of queries at which the learned method becomes cheaper than the solver. Published equal-budget work reports break-even points as low as a handful of queries for operator surrogates, but those figures come with small CPU-only budgets and should be recomputed for the actual hardware and solver at hand.

Reproducibility is part of evaluation. Record the collocation strategy, the loss weights and any adaptation schedule, the optimiser stages, the network architecture, the random seed and the exact solver version used for the baseline. In regulated industries, add independent validation datasets, model versioning, uncertainty estimates and a documented human review step. A physical equation appearing in the loss function is not, by itself, evidence that the output is physically correct.

9. How This Guide Connects to the Site

This review is the long-form layer over an index of concrete resources. The PINN getting-started collection gathers the founding papers, the mainstream solvers and representative cases into a reading path. The neural-operators and surrogate-modeling collections cover the operator side of the comparison in Section 2. The numerics-and-solvers collection and the uncertainty-quantification collection cover the classical baseline and the Bayesian formulation respectively, and the physics-AI learning path ties them together.

On the tool side, the DeepXDE, PhysicsNeMo, NeuralOperator, JAX-CFD, PhiFlow, OpenFOAM and FEniCS entries give the official links and short descriptions behind Section 6. On the case side, the chip-thermal, battery-thermal, aerodynamic CFD, hemodynamics and flow-control entries show where these methods have been applied to real engineering problems. On the benchmark side, the PDEBench and The Well entries are the starting points for Section 8. The reference list below points to the primary literature behind Sections 1 to 5.

The three layers have distinct jobs. The long-form layer supplies a defensible decision framework and its boundary conditions. The index layer turns every method family, tool and case into an openable entry: PINN getting started, neural operators, surrogate modelling, numerics and solvers, DeepXDE, PhysicsNeMo, JAX-CFD, PhiFlow, PDEBench and The Well. The primary-source layer makes each claim traceable to a paper or official documentation.

The intent is that a reader never has to take a general claim on faith: each method family, each tool and each failure mode has an indexed entry that can be opened, compared and followed to its primary source.

As the guide series grows, this review is no longer standalone. The neural operator selection guide extends the function-space contract and architecture families into an executable decision tree, while the classical solver cost boundary guide turns amortisation, break-even query counts and hybrid deployment into a reproducible calculation. Together the three cover whether a model can be trained, whether it fits the data contract, and whether it repays its cost; a reader entering from any one of them should close the other two questions before a deployment decision.

The long-form upgrade of three entries makes these links concrete: the OpenFOAM entry documents the case structure behind corpus generation and verification baselines, the NeuralOperator entry documents the FNO and TFNO implementation path, and the battery pack temperature case shows what a physics-informed loss looks like in a thermal design loop. All three are now bilingual in-depth entries that link back to this guide, to the neural operator selection guide and to the classical solver cost guide. Guides carry the judgement framework; entries carry reproducible operational detail. Where the two layers disagree, the primary sources dated in the entry govern.

10. DISCREPANCIES

1. Can PINNs replace conventional solvers for forward problems? Account A: early promotional material presents PINNs as a mesh-free general solver. Account B: equal-compute studies report that for a single forward instance with an available solver, the discretised solve finishes in milliseconds to tens of seconds while training takes minutes, and that PINNs fail on problems with shocks, jumping coefficients or turbulence. Ruling: this guide records PINNs as complementary for data fusion, inverse problems and sparse-sensor assimilation, and treats the classical solver as the baseline for single-instance forward problems. Source grade: PEER-REVIEWED versus PROJECT BENCHMARK.

2. Is a neural operator faster than a PINN? Account A: benchmark posts compare FNO inference time with PINN training time and report large speedups. Account B: the two figures measure different clocks, operator inference and per-instance training, so the comparison does not decide architectural fitness. Ruling: report amortisation and break-even query count instead of a raw speed ratio, and state which clock each figure measures. Source grade: BLOG versus PEER-REVIEWED survey.

3. Modulus or PhysicsNeMo? Account A: a large body of tutorials and papers refers to NVIDIA Modulus. Account B: the framework was renamed PhysicsNeMo, the last nvidia-modulus release was 0.9.0 in November 2024, and the 2.x releases in 2026 reorganised the API, with pip install nvidia-physicsnemo and import physicsnemo. Ruling: use PhysicsNeMo for current work, note that Modulus-era material remains conceptually applicable, and pin the version because the 2.x API moved. Source grade: VENDOR DOCUMENTATION versus SECONDARY TUTORIALS.

4. Do PINNs need no data? Account A: the defining claim is zero labelled data, with the equation supplying supervision. Account B: 2026 studies report physics-only formulations collapsing to trivial solutions on shallow-water and RANS problems, with a small number of sparse measurements breaking the degeneracy. Ruling: record physics-only training as valid in principle but fragile in practice, and treat sparse observational guidance as a standard design element rather than an exception. Source grade: PEER-REVIEWED (2019) versus PEER-REVIEWED (2026), reconciled by problem class.

5. How seriously should single-project benchmark numbers be taken? Account A: published equal-budget tables give precise error percentages and speedup ratios for PINN, FNO, graph and MLP surrogates. Account B: those numbers come from one project's small CPU-only budget, with the authors themselves describing them as directions rather than best achievable results. Ruling: cite them as directional evidence for the decision tree in Section 5, and require a local recomputation before any procurement or architecture decision. Source grade: PROJECT BENCHMARK, self-reported.

References

  1. Raissi M., Perdikaris P., Karniadakis G.E., "Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations", Journal of Computational Physics 378 (2019) 686-707.
  2. Wang S., Teng Y., Perdikaris P., "Understanding and mitigating gradient flow pathologies in physics-informed neural networks", SIAM Journal on Scientific Computing 43 (2021) A3055-A3081.
  3. Wang S., Yu X., Perdikaris P., "When and why PINNs fail to train: A neural tangent kernel perspective", Journal of Computational Physics 449 (2022) 110768.
  4. Karniadakis G.E., Kevrekidis I.G., Lu L., Perdikaris P., Wang S., Yang L., "Physics-informed machine learning", Nature Reviews Physics 3 (2021) 422-440.
  5. Li Z. et al., "Fourier Neural Operator for Parametric Partial Differential Equations", ICLR 2021.
  6. Lu L., Jin P., Pang G., Zhang Z., Karniadakis G.E., "Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators", Nature Machine Intelligence 3 (2021) 218-229.
  7. Krishnapriyan A. et al., "Characterizing possible failure modes in physics-informed neural networks", NeurIPS 2021.
  8. Wang S., Sankaran S., Perdikaris P., "Respecting causality for training physics-informed neural networks", Computer Methods in Applied Mechanics and Engineering 404 (2023) 115813.
  9. Cuomo S. et al., "Scientific machine learning through physics-informed neural networks: Where we are and what is next", Journal of Scientific Computing 92 (2022) 88.
  10. Takamoto M. et al., "PDEBench: An Extensive Benchmark for Scientific Machine Learning", NeurIPS 2022 Datasets and Benchmarks Track.
  11. "Learning PDE Solvers with Physics and Data: A Unifying View of Physics-Informed Neural Networks and Neural Operators", arXiv:2601.14517 (2026).
  12. 2026 PINN research roundup: per-loss adapters for gradient conflict, Chebyshev-centre update direction, finite-volume-informed networks and trivial-solution collapse, sparse-data guidance, and Bayesian PINN posterior contraction (2026).
  13. NVIDIA PhysicsNeMo documentation and GitHub repository (2026): framework scope, architectures, domain blueprints, and the Modulus-to-PhysicsNeMo rename.
  14. "Choosing a method: PINN, neural operator, graph network or the solver", PINNeAPPle Labs equal-budget benchmark, experiment 09 (2026): directional comparison under a fixed compute budget.
Disclaimer: This guide is compiled from public literature and documentation and does not constitute engineering or investment advice. Sources are current as of 8 November 2026. Benchmark figures quoted from a single project's equal-compute study are directional and were obtained under small CPU-only budgets; vendor documentation describes framework scope but not independent validation. Public claims about solver replacement, speed comparisons, framework naming, zero-data training and benchmark precision carry conflicting accounts (see DISCREPANCIES), and the relevant uncertainties are flagged throughout. Please rely on primary papers, official documentation and a local validation against your own solver baseline.
Tags: