SUNDIALS: time integrators and nonlinear solvers from Lawrence Livermore

One suite, six solver packages, and the equations each one targets

SUNDIALS stands for SUite of Nonlinear and DIfferential/ALgebraic equation Solvers, and it comes from the Center for Applied Scientific Computing at Lawrence Livermore National Laboratory. It is a family of software packages providing time integrators and nonlinear solvers designed to drop into existing simulation codes, written primarily in C with interfaces to C++, Fortran and Python. The audience is computational scientists and performance engineers who already have a large simulation and need a solver component they can trust, not a general-purpose scientific Python toolbox. The packages are grouped by the mathematical problem they solve, and the README spells out the equations for each, which is the fastest way to know which one you need. The design goal stated in the README is minimal information required from the user, the ability for users to supply their own data structures underneath the packages, and the ability to interface with user-supplied or third-party algebraic solvers and preconditioners.

ARKODE and CVODE cover the ODE cases, IDA the DAE case

The package list divides along the line of what you are integrating. ARKODE handles stiff, nonstiff and multirate ODEs of the form M(t) y' = f1(t,y) + f2(t,y) with an initial condition y(t0) = y0, and it is the one to look at first if your system is partitioned or runs at mixed rates. CVODE integrates ordinary ODEs y' = f(t,y) for both stiff and nonstiff problems. IDA integrates differential-algebraic equations of the form F(t,y,y') = 0, where the initial condition is given for both y and its derivative, and that extra initial condition is exactly the practical difficulty of DAE systems that the package is built to absorb. KINSOL then solves the purely algebraic side, nonlinear systems of the form F(u) = 0 or the fixed point form G(u) = u. The pairing of an implicit integrator with a nonlinear solver is the structural idea behind the suite, and it is why KINSOL is a separate package rather than a hidden option.

CVODES and IDAS add forward and adjoint sensitivity analysis

Two packages exist purely to add parameter sensitivity to an existing integrator, and this is the feature that decides whether SUNDIALS is interesting for your work or merely adequate. CVODES integrates and performs sensitivity analysis, both forward and adjoint, for ODEs of the form y' = f(t,y,p) where the initial condition itself depends on the parameters p. IDAS does the same for DAEs, F(t,y,y',p) = 0, again with parameter-dependent initial conditions. Forward sensitivities propagate the solution and its derivatives with respect to parameters, and the adjoint formulation is the one that scales when the number of parameters is large, since it propagates the adjoint solution rather than a full sensitivity matrix. For parameter estimation, optimal control or stability analysis, having the adjoint variant already implemented next to the time integrator saves a substantial amount of work, and it is the part of the suite that has no obvious substitute in a general-purpose array library.

Install from a clone, a tarball, pip or Spack

The README recommends cloning the repository, and released tarballs are also available:

git clone https://github.com/llnl/sundials.git

Full installation directions live in the getting started section of the online documentation, and the released tarballs additionally carry the instructions in INSTALL_GUIDE.pdf and in the installation chapter of the user guides in the doc directory. The Python route goes through the sundials4py package, which is available on PyPI as wheels:

pip install sundials4py

or straight from the repository:

pip install git+https://github.com/llnl/sundials.git

For HPC users who manage their software stacks declaratively, Spack is also supported:

spack install sundials

That is the whole installation story in the README, which is typical of a project of this age and maturity: the build is a CMake project with many options, and the real content is in the documentation rather than in the readme.

The Python bindings are beta, built with nanobind and CMake

The Python interface is described in the README as a beta version, and the packaging metadata confirms it is a real, modern build rather than a SWIG wrapper of old vintage. The project is named sundials4py at version 7.9.0, it requires Python 3.12 or newer, and it depends on nanobind for the bindings and numpy 2.0 or newer, with the build handled by scikit-build-core and CMake. The CMake options passed for the wheel are informative: shared libraries are turned off, CVODE and IDA are disabled, and the Python interface is enabled, so the published wheel carries the Python-facing subset rather than every solver. The build type is RelWithDebInfo, and the wheel targets the stable ABI from CPython 3.12. The repository also carries a swig directory, a bindings directory, suntools for the command line utilities, a benchmarks directory and a test directory, with example programs for each package under examples. Practical implication: a Python user gets a compiled extension, not a pure Python solver, so the install is heavier than a wheel name suggests and the platform matrix matters.

Version mixing across packages is the documented failure mode

There is one warning in the installation section that deserves to be read twice, because it is the kind of thing that only shows up after a painful afternoon. The README warns users who receive more than one of the individual packages at different times that mixing old and new versions of SUNDIALS may fail, and advises obtaining all desired packages at the same time. That constraint follows from the design, where the packages share a common core, and it is the reason the release tags are numbered for the whole suite rather than per package. The release cadence makes this manageable: v7.7.0 on 2026-04-06, v7.8.0 on 2026-06-25 and v7.9.0 on 2026-09-03, with the last push to the repository on 2026-10-19. The suite is BSD 3-clause licensed with the LICENSE and NOTICE files at the root. If you vendor the packages into a build pipeline, pin a single tag and take every package from it, and note that the version number in the release and the version in the Python package metadata are the same scheme, 7.9.0 in both.

Support comes as user guides, usage notes and an agent skill

The documentation surface is unusually complete for a scientific library. Full user guides for all packages are online, and the released tarballs include PDFs of the user guides and of the documentation for the example programs. The CHANGELOG file and the introduction chapter of any package user guide cover recent changes. There is a project FAQ covering build and installation procedures and common usage issues, and separate usage notes for systems with nonphysical solutions or discontinuities, which is a category of problem that quietly ruins many simulations and is often left undocumented. Questions that the FAQ and usage notes do not cover go to GitHub issues or the project mailing list. For teams using coding agents, the repository also ships a sundials-guide agent skill, described as helping with integrator and solver choices for a problem, which is a sensible way to expose the suite's decision criteria. Contribution is by pull request, with bug fixes and minor changes preferred, and there is a CITATIONS.md file describing how to cite SUNDIALS in publications.

Editorial conclusion

SUNDIALS fits a simulation code that needs a proven time integrator or nonlinear solver that can be dropped into an existing C codebase, with sensitivity analysis for parameter estimation and the option of GPU execution paths. It does not fit a Python-first team that wants a solver without a native build step, since the Python bindings are still described as beta and require Python 3.12 or newer. Before adopting it, read the getting started documentation for the CMake options, decide whether you need all packages or only one, and take every package from the same release, because mixing versions is the failure the README warns about explicitly.

Frequently asked questions

Official sources

1. License: BSD-3-Clause
2. llnl/sundials on GitHub
3. Project website
4. README
5. Releases