Open-source project
SciML/NeuralPDE.jl avatar
SciML/NeuralPDE.jl

The NeuralPDE readme example ends inside QuasiRandomTraining

Physics-Informed Neural Networks (PINN) Solvers of (Partial) Differential Equations for Scientific Machine Learning (SciML) accelerated simulation

1,240 stars253 forksJuliaNOASSERTION

At a glance

What is it?
NeuralPDE.jl is a Julia package that turns a symbolic differential equation into a physics-informed neural network training problem, with the loss generated for you and the discretized problem handed to ModelingToolkit. The documentation is current and the dependency stack is modern, but the one worked example in the readme breaks off mid-expression, and the citation still points at a 2021 paper.
Who is it for?
NeuralPDE.jl fits scientific machine learning work where an equation is written symbolically and the interesting work is in the loss, the boundary conditions or the training strategy rather than in the network. Learn it from the stable documentation, not from the readme, since the example there stops before the solver is called and the analysis block depends on a binding the example never creates.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 11 days ago.
What is it written in?
Mainly Julia, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • SciML/NeuralPDE.jl1,240 ★ · +17
Star history
Repository2026-09-102026-11-15
SciML/NeuralPDE.jl1.2k1.2k

17 Stars in the last 66 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The example breaks off before the solver is ever called

The readme's Poisson example is worth reading as a boundary. It sets up parameters and a symbolic function, writes the equation with the approximate operator, gives four boundary conditions as symbolic relations, defines both domains with interval objects from DomainSets, builds a three-layer chain, and then stops:

julia
discretization = PhysicsInformedNN(chain, QuasiRandomTraining(40

There is no closing parenthesis and no line after it, so the training strategy's arguments, the optimizer, the loss and the solve call are all absent. The analysis block that follows is worse off, because it evaluates a variable holding the solution that the first block never creates, and the chain above it references an activation that is never bound in the visible snippet. Copying this example verbatim cannot run. Everything past the chain lives in the stable documentation instead, which is where a first-time user will actually have to go.

The recommended citation is a five year old paper

Both the readme and the citation file at the root point at the same arXiv preprint from 2021, listing ten authors and then others, with a title about automating physics-informed neural networks with error approximations. The package is at version 7.3.1 in September 2026. Between the paper and this release the package gained the pieces that now define it: discretization to a ModelingToolkit system whose optimization problem comes from that project's own compiler, Reactant-compiled training loops, and mixing neural operators with physics-informed losses. So a citation requested by a journal points at a design that predates the features the documentation leads with, which is a small administrative problem rather than a technical one, and one an author can fix by citing the repository as well.

Two releases on one day, then a tag two seconds after the push

The release timestamps are worth a look because they show how tags are placed. v7.2.0 went out on the morning of 23 September 2026 and v7.3.0 on the evening of the same day, roughly fourteen hours later. Then v7.3.1 was published on 29 September with a timestamp two seconds after the recorded last push to the repository, which means the tag points at the tip commit rather than at a commit prepared for the release. Nothing in the readme describes a release cadence or states a stability promise for a pre one point zero line's successor. The licence question is similarly unsettled: no licence is declared on the repository, while a LICENSE.md file sits at the top level, so the terms are in that file and nowhere else.

Flux is still advertised while the example runs on Lux

The feature list names two machine learning front ends, Flux and Lux, and a third project for neural operators, with compatibility claimed for all the GPU layers those libraries provide and for DeepONets and other operators such as Fourier and graph neural operators. The example itself loads Lux and a separate optimizer wrapper rather than Flux, which matches the current direction of the ecosystem rather than the list, which still reads as if both are equally first class. The rest of the stack is visible in the tree as well: an ext/ directory for Julia package extensions, a benchmark directory at the root, and the usual split between source, tests and documentation. It is a package that has moved its centre of gravity, and the compatibility list has not been rewritten to match.

The loss is generated from a symbolic interface, not written by hand

The mechanism worth understanding is that the physics-informed loss is constructed for you. An equation is written symbolically, the approximate operator relating the differential expression to a right hand side becomes the residual, boundary conditions are a list of relations, and domains are interval objects. From that, the package builds a ModelingToolkit system whose optimization problem is generated by that project's standard compiler, which is also where weighted or constrained boundary conditions come from, along with quadrature and quasi-random training strategies. Extra loss functions can be defined on top, which is how solving is mixed with data fitting for the scientific machine learning case. So the part a researcher usually hand tunes, the residual and its weights, is where this package puts its effort.

Four equation types, one solver family

The pitch is generality across equation classes. The feature list covers physics-informed networks for ordinary differential equations, stochastic differential equations, RODEs, which combine the two, and partial differential equations, plus specialized forms for solving ordinary differential equation problems with neural networks directly and handling of various stochastic equations. The readme's own framing is that the package uses neural stochastic differential equations to solve PDEs at greatly increased generality compared with classical methods. That is the claim to test against your own problem, because the same machinery that covers four equation types is also what puts ModelingToolkit and a training strategy between you and a simple solve.

Two documentation builds, and no stated Julia version

Documentation comes in two flavours, a stable build and a development build that carries unreleased features, and the readme sends people to the latter only for what has not shipped. Installation is a single command in the package manager's own mode, with a footnote about how to leave that mode using Backspace or Control and C, which is the kind of detail that only appears when the audience is new to the ecosystem. What the readme does not state is a minimum Julia version, even though the install section opens by assuming Julia is already correctly installed. The root of the repository carries a coverage configuration, a spell checker configuration, an agents file, citation metadata, the licence file, and directories for benchmarks, documentation, extensions, source and tests.

Editorial conclusion

NeuralPDE.jl fits scientific machine learning work where an equation is written symbolically and the interesting work is in the loss, the boundary conditions or the training strategy rather than in the network. Learn it from the stable documentation, not from the readme, since the example there stops before the solver is called and the analysis block depends on a binding the example never creates. Before citing it, note that the recommended citation is a 2021 paper, and check the licence file yourself, as no licence is declared on the repository.

Frequently asked questions

How do I install NeuralPDE.jl?

With Julia already installed, add the package from the package manager's own mode by typing the add command for NeuralPDE. The readme also notes how to leave that mode, with Backspace or Control and C.

Which equation types can NeuralPDE.jl solve?

Ordinary differential equations, stochastic differential equations, RODEs which combine the two, and partial differential equations, with specialized forms for solving ordinary differential equation problems with neural networks and handling of various stochastic equations.

What does QuasiRandomTraining do in NeuralPDE.jl?

It is one of the training strategies available when an equation is discretized, alongside quadrature. In the readme's two-dimensional Poisson example it is the last thing shown before the example breaks off mid-call, so its arguments and everything after it are left to the documentation.

Can NeuralPDE.jl mix equation solving with data fitting?

Yes. Extra loss functions can be defined so that solving is mixed with data fitting, which is the scientific machine learning path, and the physics-informed loss itself is constructed automatically from the symbolic interface rather than written by hand.

Which neural network libraries does NeuralPDE.jl work with?

Flux.jl and Lux.jl for the GPU machine learning layers they provide, and NeuralOperators.jl for mixing DeepONets and other neural operators such as Fourier and graph neural operators with physics-informed loss functions.

What licence does NeuralPDE.jl use?

No licence is declared on the repository, while a LICENSE.md file sits at the top level. The terms are therefore only in that file, so read it directly before reuse.

Official sources

  1. Issues
  2. Project website
  3. README
  4. Releases
  5. SciML/NeuralPDE.jl on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/sciml-neuralpde-jl.svg)](https://hysenlabs.com/projects/sciml-neuralpde-jl)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/sciml-neuralpde-jl.svg)](https://hysenlabs.com/projects/sciml-neuralpde-jl)

Was this useful?