DeepXDE

New
License: GNU Lesser General Public License v2.1 · Updated 2026-11-16
Evidence: Primary sourceVerified: 2026-11-1612 sourcesView evidenceHide evidence
Scope and limits

Verification covers the licence and maintenance state of the official repository, the release timeline, the PyPI version metadata and Python requirement, the conda-forge version and upload time, the module structure and backend implementations in the published v1.15.1 source tree, the capability list in the official README and installation documentation, the SIAM Review citation paper, the metadata of the DeepONet paper in Nature Machine Intelligence, the arXiv preprint record, and the body of the weak-baseline review by McGreivy and Hakim. Five facts were corrected: the latest stable release is v1.15.1 (2 November 2026), with the GitHub tag, the PyPI upload and the conda-forge build all agreeing on the same date, while the v1.15.0 release date given as 6 December 2025 was actually 5 December 2025; reference 4 mixed a title and a journal, since the formal title in Nature Machine Intelligence 3(3), 218-229 (2021) is Learning nonlinear operators via DeepONet based on the universal approximation theorem of operators with DOI 10.1038/s42256-021-00302-5, while the wording used in the entry was the arXiv preprint title; the paper attributed to Guo M. and colleagues in reference 9 could not be found in either arXiv or Crossref, so the body and the reference now point at the official example and tutorial set; the 1e-3 to 1e-4 relative L2 error range quoted from community write-ups could not be traced to a single primary source, so the body treats it as a community capability statement with a lower evidence level; and the framework runs in single precision by default, with mixed precision requiring explicit activation and available only on some backends, which contradicts the default mixed single and double precision claim in the entry. Three coverage details were also added: among the three automatic-differentiation modes listed in the README, zero coordinate shift ships as a separate module, deepxde.zcs, that augments DeepONet, the residual network architecture is implemented only for the TensorFlow 1.x backend, and Horovod multi-GPU data-parallel training is limited to that same backend; the repository showed 4,511 stars, 1,017 forks and a latest commit on 16 November 2026; and the volume, issue, pages and DOI of the McGreivy and Hakim paper were completed. Third-party community accuracy figures, cross-framework performance comparisons and vendor-reported benchmarks are outside the scope of this verification.

#SourceTypePublished / Accessed
1DeepXDE official code repositoryGitHubRepository2019-02-08 / 2026-11-16
2DeepXDE release record (latest v1.15.1, 2 November 2026)GitHubRepository2026-11-02 / 2026-11-16
3deepxde release record (1.15.1, Python 3.9 and newer)Python Package IndexDatabase2026-11-02 / 2026-11-16
4DeepXDE on conda-forge (1.15.1, 2 November 2026)Anaconda.orgDatabase2026-11-02 / 2026-11-16
5DeepXDE README (feature list and backend dependency floors)DeepXDE projectDocumentationNot stated / 2026-11-16
6DeepXDE installation and backend documentation (PyTorch 2.0.0 floor)Read the DocsDocumentationNot stated / 2026-11-16
7DeepXDE v1.15.1 backend configuration source (default precision and autodiff modes)GitHubRepository2026-11-02 / 2026-11-16
8DeepXDE v1.15.1 zero coordinate shift module (deepxde/zcs)GitHubRepository2026-11-02 / 2026-11-16
9DeepXDE citation paper (SIAM Review 63(1), 208-228, 2021)SIAMPaper2021-01-01 / 2026-11-16
10DeepXDE preprint (arXiv:1907.04502)arXivPaper2019-07-10 / 2026-11-16
11DeepONet paper (Nature Machine Intelligence 3(3), 218-229, 2021)Springer NaturePaper2021-03-18 / 2026-11-16
12Weak baselines and reporting biases review (Nature Machine Intelligence 6(10), 1256-1269, 2024)Springer NaturePaper2024-09-25 / 2026-11-16

The verification date covers only what was checked in that pass; it does not mean every figure on this page was independently verified.

My rating

1. Overview

DeepXDE is a mature library for scientific machine learning and physics-informed learning, maintained by Lu Lu and contributors since 2019 and released under LGPL-2.1. Its defining strength is that the user describes a PDE or ODE as a residual and a set of boundary and initial conditions, and the library handles training, automatic differentiation, sampling, and network assembly, so the gap between the mathematical statement and the running program is small. This guide is written for three readers: a newcomer who wants the gentlest possible entry into PINNs and operator learning; a teacher or student who needs a tool whose code reads like the equation; and a machine-learning engineer who must solve forward or inverse differential equations without writing a finite-element or finite-difference solver from scratch. The companion guides on the PINN landscape and neural-operator selection supply the decision frameworks; this entry provides the DeepXDE-specific detail. All version and capability statements below were verified against the project repository, release pages, PyPI and the DeepXDE 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.

DeepXDE is a framework and a teaching instrument, not a black-box simulator with a graphical interface; it produces networks that approximate solutions and parameters, and it remains the reference against which a surrogate's accuracy is measured, sitting beside JAX-Fluids for differentiable CFD and Poseidon for PDE foundation models on a different contract. After reading, you should be able to judge whether, in a concrete forward or inverse problem, DeepXDE is the right workhorse or only part of the pipeline.

2. How It Works

The workflow begins by defining a geometry and a time domain, then writing the PDE residual as a Python function that uses DeepXDE's gradient operators (jacobian and hessian) to express derivatives, and finally declaring boundary and initial conditions through Dirichlet, Neumann, Robin, periodic or general point-set constraints. DeepXDE samples residual points inside the domain and on the boundary, builds a composite loss from the PDE residual and the conditions, and trains a neural network with Adam and L-BFGS. Because derivatives come from automatic differentiation rather than finite differences, the residual is exact at any sampled point, and the method is mesh-free in the sense that it trains on scattered points rather than a structured grid. Residual-based adaptive refinement (RAR) iteratively adds points where the residual is large, which helps with sharp gradients and singularities.

The library is backend-agnostic: the same problem code runs on TensorFlow 1.x, TensorFlow 2.x, PyTorch, JAX or PaddlePaddle by changing only the import and the installed backend, with PyTorch requiring at least version 2.0.0 and Python 3.12 supported. Internally DeepXDE offers three automatic-differentiation modes (reverse, forward, and zero-coordinate-shift), several network architectures (fully connected, stacked, residual, multi-scale Fourier-feature), and function spaces such as power series, Chebyshev polynomials and Gaussian random fields, so a user can match the ansatz to the problem rather than rewriting the solver. Two coverage details matter before a run is planned: the zero-coordinate-shift mode ships as a separate module (deepxde.zcs) that augments DeepONet rather than as a value of the global autodiff setting, and the residual (ResNet) architecture is implemented only for the TensorFlow 1.x backend.

3. Scope and Assumptions

DeepXDE assumes you bring a problem expressible as differential equations with conditions you can write down: forward problems with initial and boundary data, and inverse problems where some parameters or fields are unknown and recovered from measurements. It covers ordinary, partial, integro-differential and fractional differential equations, plus stochastic partial differential equations and operator learning with DeepONet-family architectures. It is not a high-performance CFD or FEM engine; it does not mesh a complex geometry for you beyond constructive-solid-geometry primitives and point clouds, and it will not compete with a parallel classical solver on raw throughput for a single large query. The accuracy of the result depends on network size, sampling, loss weighting and training length, none of which the framework chooses for you.

Platform assumptions are concrete. Installation is a pip or conda-forge package (conda install -c conda-forge deepxde), and the LGPL-2.1 licence permits use, modification and linking in proprietary pipelines provided that modifications to the DeepXDE libraries themselves are shared; importing the Python interface does not trigger copyleft on your own code. The framework's value is greatest inside a validated modelling 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 a PINN can satisfy 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 a single package: pip install deepxde or the conda-forge equivalent, after which the documented demos (function approximation, forward problems, inverse problems, operator learning) are the fastest way to see a working configuration. A first problem follows the documented workflow: define the geometry with built-in primitives (Interval, Rectangle, Disk, Cuboid, Sphere) or construct solid geometry by union, difference and intersection, define the PDE residual with dde.grad, declare the conditions with the icbc module, assemble the data object with training and test points, and train. The official DeepXDE tutorials and ReadTheDocs walk through the 1D diffusion inverse problem, the reaction-diffusion inverse problem and the Burgers equation as the fastest path rather than starting from an empty script. The most frequent beginner failure is mixing a backend that was not installed with the import path, which raises a runtime error; confirming the backend before importing removes that confusion.

Before trusting a result, run a manufactured-solution test: construct a problem whose exact solution is known, train, and confirm the relative L2 error is consistent with the network capacity and sampling, because if it is not, the problem is the residual, the conditions or the sampling rather than the solver. Then evaluate any surrogate or recovered parameter on a held-out configuration with an independent reference. The companion DeepXDE tutorial and the physics-based deep-learning material on this site collect supporting detail, and the PINN landscape guide organises when a PINN is worth the compute. Record the version, the backend, the network architecture and the sampling settings next to every result, because those four 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. JAX-Fluids and PhysicsNeMo are differentiable or surrogate engines tuned for fluid dynamics and large-scale training, whereas DeepXDE is a general, equation-first library tuned for readability and quick validation across many PDE types. Poseidon is a pretrained foundation model queried like an operator, whereas DeepXDE trains a network from scratch for the specific equation you provide. JAX-CFD is a differentiable solver on accelerators for a narrower physical regime, and NVIDIA Warp is a JIT-compiled differentiable simulation language, both different from an equation-residual library. NeuralOperator provides trained operator architectures such as FNO, which DeepXDE also implements through its DeepONet family, so the two overlap on operator learning but differ in workflow and scale.

Within PINN tooling, DeepXDE's differentiator is the declarative equation-to-code mapping plus the breadth of problem types (fractional, stochastic, integro-differential, operator learning) in one package, with Chinese documentation that lowers the entry barrier. A classical reduced-order model or a surrogate such as NeuralOperator can accelerate a repeated query once trained, but neither generates its own training data nor supplies a verified reference the way a classical solver does. The PINN landscape guide and the neural-operator selection guide keep these comparisons honest by stating the deliverable: a certified single solve, an interactive design sweep, or a surrogate that amortizes thousands of queries. A framework that wins on usability may lose on a project where throughput or certified accuracy dominates.

6. Benchmarks and Evidence

Public evidence is largely the project's own tutorial suite plus a large body of academic validations. The DeepXDE paper (Lu, Meng, Mao and Karniadakis, SIAM Review 63(1), 208-228, 2021; arXiv 1907.04502) demonstrates PINN and DeepONet on Poisson, diffusion-reaction and other canonical problems and reports relative L2 errors that fall with network capacity and adaptive sampling. Community reproductions apply DeepXDE to forward and inverse PDE problems, and community write-ups of simple 2D Poisson and diffusion cases cite relative L2 errors on the order of 1e-3 to 1e-4 and parameter recovery within a few percent under moderate noise. These are community capability statements that this verification could not trace back to a single primary source, and they are not independent blind validations of accuracy or speed at scale.

Independent work tempers the optimism. A review of seventy-six papers claiming machine learning beats classical solvers found that seventy-nine percent compared against a weak baseline, which is a reminder that any accuracy figure from a PINN trained with DeepXDE should be re-measured on an independent reference. A 2026 practitioner study found that classical linear reduced-order models stayed more accurate and equally fast as a neural surrogate under conditions favourable to linear methods. These are not reasons to reject DeepXDE; they are reasons to treat any result as unverified until the network, sampling, backend and hardware are stated. Any number used in a proposal should come from a local run whose configuration, backend and version string are archived, following the same discipline used by the bridge-structural case and the additive-manufacturing case on this site.

7. Role in Physics-AI Workflows

In a production pipeline DeepXDE sits at the rapid-prototyping and inverse-problem end. It generates paired input and output fields for training surrogates, supplies reference solutions for hybrid models that learn a correction term, and remains the reference against which any surrogate's error is measured. The value concentrates in small-data or inverse regimes inside a narrow, validated distribution: a DeepXDE-trained PINN can recover an unknown coefficient or a hidden field from sparse, noisy observations, and its credibility rests entirely on how the problem was posed and how thoroughly the result was validated against held-out data. PDEBench and similar corpora are examples where classical and neural solvers provide the ground truth that surrogates learn from.

DeepXDE also fits into a longer verification chain. A classical solver remains the reference for correctness and for any certification claim; 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 for operator learning. 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 PINN getting-started collection collects the underlying entry points. Writing down the expected query count before training is still the cheapest way to avoid an unrecoverable investment; that discipline connects directly to the cost-boundary guide, because the query count is the variable that decides whether a fixed data-generation cost is ever recovered.

8. Limitations and Failure Modes

PINN accuracy inherits every limitation of the residual-minimisation approach. A poorly posed residual, a bad loss weighting, or too few residual points yields results that are smooth and plausible yet wrong, and the network will not flag that for you; manufactured-solution and convergence testing is the only cheap guard. High-dimensional or multi-scale problems strain a single multi-layer perceptron, and sharp discontinuities such as shocks are smeared unless the architecture or sampling is adapted. Boundary-condition implementation is expressive but unforgiving - a mis-labelled point set silently changes the problem rather than raising an error.

There are practical limits too. DeepXDE is Python and backend-centric, so effective use on a cluster needs batch-scheduler competence separate from the physics, and it does not offer the parallel throughput of a compiled classical solver for a single large query. Training is sensitive to hyperparameters (network depth, sampling density, optimiser schedule), so two runs can differ; recording the seed, architecture and sampling settings is mandatory for reproducibility. DeepXDE runs in single precision by default; mixed precision has to be enabled explicitly and is available only on some backends. DeepXDE does not provide a certified accuracy or an audit trail on its own; when the deliverable must be defended, a classical 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. Treating a PINN's smooth output as ground truth near a singularity is a modelling error, not a tool failure.

9. Version and Source Notes

Record 1: DeepXDE is actively maintained; the latest stable release is v1.15.1 (2 November 2026), and GitHub, PyPI and conda-forge all carry that same version and release date, while the preceding release v1.15.0 was published on 5 December 2025. Record 2: the framework supports five tensor backends - TensorFlow 1.x, TensorFlow 2.x, PyTorch, JAX and PaddlePaddle - and the choice is made at import time, not in the problem code. Record 3: the project's citation paper is Lu, Meng, Mao and Karniadakis, "DeepXDE: A deep learning library for solving differential equations", SIAM Review 63(1), 208-228 (2021), doi 10.1137/19M1274067; the preprint is arXiv 1907.04502. Record 4: the licence is LGPL-2.1, which permits use and modification in proprietary pipelines provided that changes to the DeepXDE libraries themselves are shared; importing the Python interface does not trigger copyleft on surrounding code.

Record 5 (reconciliation discipline): when citing a DeepXDE result, the version, the backend (for example PyTorch 2.x), the network architecture and the sampling settings must be recorded together, because the trained network and its error depend on exactly those choices. A relative L2 error quoted without its backend and sampling cannot be reproduced and should not be carried into a proposal. The LGPL-2.1 licence permits commercial and proprietary use with the modification-sharing condition noted above. All records were verified on 16 November 2026 against the project repository, release pages, PyPI, conda-forge, the published source tree of v1.15.1 and the DeepXDE documentation; vendor-stated benchmark figures are treated as project-authored capability statements rather than independent validations. The repository showed 4,511 stars and 1,017 forks on that date.

10. References

  1. Lu L., Meng X., Mao Z., Karniadakis G. E., "DeepXDE: A deep learning library for solving differential equations", SIAM Review 63(1), 208-228 (2021), doi 10.1137/19M1274067.
  2. Lu L. et al., "DeepXDE: A deep learning library for solving differential equations", arXiv:1907.04502.
  3. The DeepXDE Project, "DeepXDE documentation", deepxde.readthedocs.io (accessed 16 November 2026).
  4. 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(3), 218-229 (2021), doi 10.1038/s42256-021-00302-5.
  5. Lu L., "DeepXDE repository", GitHub, github.com/lululxvi/deepxde (accessed 16 November 2026).
  6. DeepXDE release v1.15.1, GitHub releases, github.com/lululxvi/deepxde (released 2 November 2026); the preceding release v1.15.0 was published on 5 December 2025.
  7. DeepXDE on conda-forge, anaconda.org/conda-forge/deepxde (version 1.15.1, 2 November 2026).
  8. Raissi M., Perdikaris P., Karniadakis G. E., "Physics-informed neural networks", Journal of Computational Physics 378, 686-707 (2019).
  9. DeepXDE example and tutorial material, the function approximation, forward problem, inverse problem and operator learning demo sets.
  10. McGreivy N., Hakim A., "Weak baselines and reporting biases lead to overoptimism in machine learning for fluid-related partial differential equations", Nature Machine Intelligence 6(10), 1256-1269 (2024), doi 10.1038/s42256-024-00897-5, arXiv:2407.07218.
Tags: