PhysicsNeMo
New1. Overview
PhysicsNeMo is NVIDIA's open-source physics-machine-learning framework, built on PyTorch and released under the Apache-2.0 licence. It was renamed from Modulus in early 2025 after a trademark settlement, so the current package is nvidia-physicsnemo and the repository is NVIDIA/physicsnemo. This guide is written for three readers: an algorithm engineer choosing a framework to train a physics-informed or operator-style surrogate; a CAE lead deciding whether a surrogate can replace or accelerate a classical solve; and a reviewer checking a vendor claim that an AI model "beats CFD". The companion guides on neural operator selection, classical-solver cost boundaries and the PINN landscape give the decision frameworks; this entry supplies the framework-specific detail. All version and capability statements below were verified against the project repository, PyPI metadata and NVIDIA documentation on 16 November 2026, and any claim that is the project's own description rather than an independent measurement is labelled as such in Section 9.
The framework is a training library, not a solver. It does not generate the training corpus, which is the job of a classical tool such as OpenFOAM or FEniCS, and it does not stand in for the reference solve that measures surrogate error. It sits alongside SU2 for aerodynamic optimisation and JAX-CFD for differentiable simulation, on a different contract from each. This entry explains what it actually provides, how its versions have evolved, how it compares with neighbouring tools, where it fails, and how its version claims should be reconciled, so that a benchmark number from a vendor chart is not mistaken for a reproducible conclusion. After reading, you should be able to judge whether, in a concrete physics-AI project, the framework is the right workhorse or only one stretch of the pipeline.
2. How It Works
The framework is organised around a training loop that combines several loss terms: a data-fitting term, a physics-residual term derived from the governing equations, and boundary or initial-condition terms, weighted through configurable aggregation. Its automatic-differentiation backend differentiates the network output with respect to spatial and temporal inputs, so partial derivatives that a finite-volume code would compute by differencing are obtained analytically. That backend is the foundation of the physics-informed path, where a PDE residual is evaluated on sampled points and added to the objective. The network layer provides optimised implementations of multilayer perceptrons, Fourier-feature networks and modified MLPs with multiplicative filter layers, plus operator and transformer families such as FNO, AFNO, GeoTransolver, FLARE, DoMINO and Transolver, and a GLOBE model added in version 2.1.0.
Two packages make up the framework. The core package provides model architectures, SciML data pipelines for structured and unstructured grids, distributed-training utilities and checkpointing. The symbolic package, folded into the core as physicsnemo.sym since version 2.1.0, lets a user declare PDEs in SymPy and select a gradient method, so spatial derivatives are computed automatically. The standalone physicsnemo-sym repository was archived on 29 May 2026. A separate diffusion module (physicsnemo.diffusion) supplies denoisers, samplers and noise schedulers for generative SciML, which is a different contract from a deterministic surrogate and should be evaluated on its own terms. Keeping the deterministic field predictor and the sampling generator as distinct ideas is the precondition for reading the framework's capabilities correctly, because conflating them produces claims the framework was never built to support.
3. Scope and Assumptions
The framework assumes you bring a training problem that fits one of its supported contracts: a physics-informed problem where a PDE residual supplies supervision and labelled fields may be scarce; an operator problem where paired input and output fields are available from a solver such as OpenFOAM or FEniCS; or a data-driven surrogate over a fixed geometry family. It is not a solver itself and does not generate the corpus - that work belongs to a classical tool, and the cost of producing the corpus is part of the project budget described in the cost-boundary guide. The physics-residual term is derived from the same equations you code, so it cannot correct a systematic modelling error in the formulation; if the boundary condition or constitutive law is wrong, the residual agrees with the wrong answer and gives no signal about the discrepancy.
Platform assumptions are concrete. The 2.x line requires Python 3.11 or newer, and the torch 2.10.0 floor arrives with version 2.1.0 and is carried by every later release, 2.2.2 included. CUDA backends are selected with the cu12 or cu13 extra, and container images use year.month tags that do not match the pip version numbers, so a report must name which artifact it used; the tags published in the NGC catalogue run from 25.03 to 26.08 and stop there. The Apache-2.0 licence permits commercial use and modification, which is a legal matter for the user's own review rather than a technical guarantee here. The framework's value is greatest inside a validated design envelope; it is not a substitute for certification-grade verification when the deliverable is a safety-critical component. A mismatch between the problem you hand it and the contract it supports is the most common source of disappointment, and the section on failure modes returns to this point with concrete examples of what a violated assumption looks like in practice.
4. Getting Started
Installation is documented as pip install nvidia-physicsnemo with optional extras such as cu13, nn-extras and sym. Import paths changed from import modulus to import physicsnemo during the rename, so older tutorials that still reference modulus will fail and should be updated before any code is copied. A first physics-informed run follows the documented workflow: define the geometry or import a mesh, declare the PDE with the symbolic interface, set up sampling, then train with the provided training utilities. The repository ships example recipes - external aerodynamics with GeoTransolver, weather nowcasting with a Stormscope architecture, and automotive crash - that are the fastest way to see a working configuration rather than starting from an empty script. The most frequent beginner failure is running a tutorial written for Modulus, hitting an import error, and concluding the framework is broken; checking the installed package name removes that confusion.
Before scaling up, run a small overfitting sanity check: confirm the network can drive the training residual near zero on a few hundred samples, because if it cannot, the problem is the data contract or the PDE encoding, not capacity. Then evaluate on held-out coefficients and, for operator models, at a resolution different from the training grid with a freshly computed reference from a classical solver. The companion FNO tutorial and the practical neural-operator tutorial on this site collect supporting material, and the neural-operator selection guide organises when an operator model rather than a PINN is the right choice. Record the installed version, the CUDA extra and the random seed next to every checkpoint, because those three values are what make a result reproducible, and a result that cannot be reproduced cannot be defended to a customer.
5. Comparison with Alternatives
The useful comparison is by contract. NeuralOperator is a library that learns a map from coefficients or forcing to a solution field across a parametric family and needs a paired corpus produced by something like OpenFOAM; PhysicsNeMo can produce that corpus-conditioned training but also covers the residual-supervised path where no labelled field exists. DeepXDE and PhysicsNeMo both provide physics-informed infrastructure, but PhysicsNeMo's PyTorch-native, composable design and distributed-training utilities target larger industrial runs. SU2 and OpenFOAM are solvers, not training frameworks: they generate the fields a surrogate learns from and remain the reference against which surrogate error is measured. JAX-CFD and PhiFlow are differentiable solvers whose value is a gradient through the simulation, useful for solver-in-the-loop training, whereas PhysicsNeMo trains a standalone network. A foundation-style model such as Poseidon provides a pretrained starting point across tasks, a different proposition from training one surrogate for one geometry.
Within NVIDIA's own stack, the contrast is between deterministic surrogates (GeoTransolver, FLARE, DoMINO, Transolver) and the generative diffusion module. One returns a field for a given input; the other samples plausible fields and needs its own validation protocol. A classical reduced-order model - proper orthogonal decomposition with an interpolated coefficient vector - is also a legitimate comparator and is often cheaper to audit. JAX-Fluids is a differentiable alternative worth considering when the requirement is a gradient through a compressible-flow solve rather than a trained surrogate. The neural-operator selection guide and the cost-boundary guide keep these comparisons honest by stating the deliverable: a single certified solve, an interactive design sweep, or an inverse problem with gradients. A framework that wins a benchmark on a fixed GPU forward pass may lose on a project where corpus generation and validation dominate.
6. Benchmarks and Evidence
Public evidence is a mix of vendor-reported metrics and independent cautions. On the DrivAerML road-car dataset, the DoMINO example reports a drag-coefficient R-squared of 0.983 for a surface-only model and 0.975 for a combined surface-and-volume model, measured against reference CFD; the same family of results appears in the ML4CFD competition, where the neural architectures OB-GNN, MARIO and GeoMPNN reported speedups of roughly 300x to 600x over a conventional solver, while the top-ranked entry was the classical mesh-morphing Gaussian-process method MMGP, which reached a higher predictive accuracy at a much lower speed-up, so the global score weighted accuracy above speed. NVIDIA's PhysicsNeMo CFD module, introduced in May 2026, adds config-driven benchmarking that reports L2 pressure, velocity and turbulent-viscosity error plus integrated drag and lift errors, so a domain expert can run a pretrained checkpoint with a few YAML changes. These are project-authored capability statements, not independent validations of accuracy or speed.
Independent work tempers the optimism. A 2026 practitioner study compared a PhysicsNeMo surrogate with classical linear reduced-order models on a single consumer GPU and found that, under conditions favourable to linear methods, the classical approach stayed more accurate and equally fast, with the neural model degrading under autoregressive rollout on sharp-interface data. A review of 76 papers claiming machine learning beats classical solvers found that 79 percent compared against a weak baseline. These are not reasons to reject the framework; they are reasons to treat any speedup figure as unverified until the baseline, accuracy, grid and hardware are stated. Any number used in a proposal should come from a local run whose corpus, checkpoint and version string are archived, following the same discipline used by the openfoam-multiphysics case and the aerospace-cfd case on this site.
7. Role in Physics-AI Workflows
In a production pipeline PhysicsNeMo sits between a solver and a consumer. A solver such as OpenFOAM or FEniCS produces paired fields; the framework trains the surrogate; the consumer queries it for design sweeps, uncertainty loops or inverse problems. The value concentrates in repeated queries inside a narrow, validated distribution. If the same configuration is queried once, training cost dominates; if it is queried tens of thousands of times, amortisation may work, subject to the four ledgers in the cost-boundary guide. The framework's unified mesh-processing module and its support for converting PyVista, VTK and VTU meshes make the data preparation step less bespoke, which matters because mesh handling is where most engineering effort lands, and that contribution is easy to underrate.
The framework also fits into a longer verification chain. A classical solver remains the reference for correctness; a physics-informed model can supply residual corrections where labels are scarce, following the PINN landscape guide; a foundation-style model such as Poseidon can provide a pretrained starting point. None of these removes the need for an independent reference solve on held-out configurations. The physics-AI learning path on this site places these roles in sequence, and the framework's embedded out-of-distribution guardrail, introduced in version 2.1.0, is one mechanism for routing an untrusted query back to the solver. Writing down the expected query count before training is still the cheapest way to avoid an unrecoverable investment; that discipline connects directly to the four ledgers of the cost-boundary guide, because the query count is the variable that decides whether the fixed training cost is ever recovered.
8. Limitations and Failure Modes
Spectral and truncation assumptions are modelling choices. An operator model that learns on one discretisation carries that discretisation's spectral bias, and a change of grid does not by itself transfer the physics, as independent studies on resolution equivariance have shown for Fourier operators. Autoregressive rollout accumulates error: a small one-step bias becomes a distribution shift at the next step, and long-horizon trajectories can drift or become physically implausible. Boundary conditions and conservation laws are not enforced exactly by a data-driven or residual-weighted loss, so mass or energy drift can coexist with a good-looking field. Out-of-distribution failure is often silent: predictions stay smooth and bounded while being wrong, which is exactly the case the embedded guardrail is meant to flag, but the guardrail itself must be calibrated during training and does not become effective on its own.
There are practical limits too. The 2.x line's Python 3.11 floor and the torch 2.10 requirement that arrives with 2.1.0 constrain deployment environments, and container image tags do not match pip versions, so provenance must be recorded explicitly. The framework does not provide certified accuracy or an audit trail on its own; a vanilla finite-volume solver such as OpenFOAM remains the reference when the deliverable must be defended. Maintenance cadence is the other practical constraint: the repository carries roughly 3,447 stars, the latest commit reached the default branch on 14 November 2026, and the published release line has not moved past 2.2.2 since 11 September 2026, so a plan that assumes a new minor version every quarter needs a fallback. The generative diffusion module is a different contract and should not be conflated with a deterministic surrogate. When the deliverable requires certification or a safety envelope, a fresh high-fidelity solve, or an experiment, stays in the loop as the reference, and the cost-boundary guide explains why a deferral rule back to the solver belongs in the design.
9. Version and Source Notes
Record 1: PhysicsNeMo is the renamed NVIDIA Modulus. The rename followed a trademark settlement in early 2025; the PyPI package became nvidia-physicsnemo, the repository moved from NVIDIA/modulus to NVIDIA/physicsnemo, and import paths changed from modulus to physicsnemo. The last nvidia-modulus release was 0.9.0 on 27 November 2024. The rename was a branding change, not a functional break: code that imported the framework under the old name simply needs its imports and package reference updated, and the existing model checkpoints remain loadable once the import path is corrected. Record 2: version 1.3.0 was released in November 2025; 2.0.0 on 9 March 2026; 2.1.0 on 26-27 May 2026; 2.1.1 on 8 June 2026; 2.2.0 on 27 August 2026; 2.2.1 on 31 August 2026; and 2.2.2 (a documentation fix) on 11 September 2026. The catalogue year value of 2023 refers to the original Modulus era, not a software release date, and should not be quoted as one.
Record 3: the 2.x line requires Python 3.11 or newer, with an upper bound that moves from below 3.14 in 2.0.0 and 2.1.x to below 3.15 in 2.2.2; the torch 2.10.0 floor arrives with 2.1.0, while 2.0.0 still accepted torch 2.4.0. CUDA backends are chosen with the cu12 or cu13 extra, and NGC container tags use a year.month scheme that does not match the pip version; the tags listed in the NGC catalogue run 25.03, 25.06, 25.08, 25.11, 26.03, 26.05, 26.06 and 26.08. Record 4: the symbolic package physicsnemo.sym became part of nvidia-physicsnemo in 2.1.0 (the standalone physicsnemo-sym repository was archived on 29 May 2026), and the 2.1.0 release added a GLOBE model, PyVista/VTK/VTU mesh conversion, and an embedded out-of-distribution guardrail. Record 5: the Apache-2.0 licence is confirmed from the repository LICENSE file and PyPI metadata; it permits commercial use and modification, which is a licence description rather than legal advice. Record 6: vendor-reported metrics such as DoMINO's drag R-squared on DrivAerML are the project's own benchmark statements and are not independent validations. All records were verified on 16 November 2026 against the repository, PyPI and NVIDIA documentation.
10. References
- NVIDIA, "PhysicsNeMo: An open-source framework for physics-AI applications", GitHub repository, github.com/NVIDIA/PhysicsNeMo (accessed 16 November 2026).
- NVIDIA, "PhysicsNeMo documentation and installation", docs.nvidia.com/physicsnemo (accessed 16 November 2026).
- NVIDIA, "PhysicsNeMo CFD: config-driven benchmarking and evaluation", NVIDIA Developer Blog, nvidia.github.io/physicsnemo/blog/2026/05/29/physicsnemo-cfd (accessed 16 November 2026).
- Raissi M. et al., "Hidden fluid mechanics: Learning velocity and pressure fields from flow visualizations", Science 367 (2020) 1026-1030.
- Li Z. et al., "Fourier Neural Operator for Parametric Partial Differential Equations", ICLR 2021, arXiv:2010.08895.
- Kochkov D. et al., "Machine learning accelerated computational fluid dynamics", Proceedings of the National Academy of Sciences 118 (2021) e2101784118.
- Technical University of Munich (Adams group), "TorchLBM: a differentiable lattice-Boltzmann solver with FNO hybrid steps", NVIDIA Developer Blog (accessed 16 November 2026).
- McGreivy N., Hakim A., "Weak baselines and reporting biases lead to overoptimism in machine learning for fluid-related partial differential equations", Nature Machine Intelligence (2024), arXiv:2407.07218.
- Fujiwara H., "A Practitioner's Reality Check: Classical CFD vs. Neural Surrogates on a Single Consumer GPU", Zenodo record 21944611 (2026).
- NVIDIA, "nvidia-physicsnemo 2.2.2 PyPI metadata (Licence-Expression: Apache-2.0, Requires-Python >=3.11)", PyPI (accessed 16 November 2026).