SciML · ChrisRackauckas · Jul 12, 2026 · Jul 10, 2026 · Jul 11, 2026 · Jul 11, 2026
diff --git a/Project.toml b/Project.toml
@@ -72,7 +72,7 @@ SafeTestsets = "0.1"
 SciMLBase = "2.148.0, 3"
 SciMLLogging = "1.10.1, 2"
 SciMLSensitivity = "7.100.0"
-SciMLTesting = "1"
+SciMLTesting = "2.1"
 SparseArrays = "1.10"
 Symbolics = "7"
 TerminalLoggers = "0.1"

diff --git a/docs/make.jl b/docs/make.jl
@@ -1,5 +1,11 @@
 using Documenter, Optimization
-using OptimizationLBFGSB, OptimizationSophia, SimpleOptimization
+using OptimizationAuglag, OptimizationBBO, OptimizationBase
+using OptimizationCMAEvolutionStrategy, OptimizationGCMAES, OptimizationIpopt
+using OptimizationLBFGSB, OptimizationMadNLP, OptimizationManopt
+using OptimizationNLPModels, OptimizationNOMAD, OptimizationODE
+using OptimizationPolyalgorithms, OptimizationPRIMA, OptimizationPyCMA
+using OptimizationQuadDIRECT, OptimizationSciPy, OptimizationSophia
+using OptimizationSpeedMapping, SimpleOptimization
 
 cp(joinpath(@__DIR__, "Manifest.toml"), joinpath(@__DIR__, "src/assets/Manifest.toml"), force = true)
 cp(joinpath(@__DIR__, "Project.toml"), joinpath(@__DIR__, "src/assets/Project.toml"), force = true)
@@ -10,8 +16,14 @@ makedocs(
     sitename = "Optimization.jl",
     authors = "Chris Rackauckas, Vaibhav Kumar Dixit et al.",
     modules = [
-        Optimization, Optimization.SciMLBase, Optimization.OptimizationBase, Optimization.ADTypes,
-        OptimizationLBFGSB, OptimizationSophia, SimpleOptimization,
+        Optimization, Optimization.SciMLBase, Optimization.OptimizationBase,
+        OptimizationAuglag, OptimizationBBO, OptimizationBase,
+        OptimizationCMAEvolutionStrategy, OptimizationGCMAES, OptimizationIpopt,
+        OptimizationLBFGSB, OptimizationMadNLP, OptimizationManopt,
+        OptimizationNLPModels, OptimizationNOMAD, OptimizationODE,
+        OptimizationPolyalgorithms, OptimizationPRIMA, OptimizationPyCMA,
+        OptimizationQuadDIRECT, OptimizationSciPy, OptimizationSophia,
+        OptimizationSpeedMapping, SimpleOptimization,
     ],
     clean = true, doctest = false, linkcheck = true,
     warnonly = [:missing_docs, :cross_references],

diff --git a/docs/pages.jl b/docs/pages.jl
@@ -27,11 +27,13 @@ pages = [
     ],
     "Optimizer Packages" => [
         "BlackBoxOptim.jl" => "optimization_packages/blackboxoptim.md",
+        "AugLag.jl" => "optimization_packages/auglag.md",
         "CMAEvolutionStrategy.jl" => "optimization_packages/cmaevolutionstrategy.md",
         "Evolutionary.jl" => "optimization_packages/evolutionary.md",
         "GCMAES.jl" => "optimization_packages/gcmaes.md",
         "Ipopt.jl" => "optimization_packages/ipopt.md",
         "LBFGSB.jl" => "optimization_packages/lbfgsb.md",
+        "MadNLP.jl" => "optimization_packages/madnlp.md",
         "Manopt.jl" => "optimization_packages/manopt.md",
         "MathOptInterface.jl" => "optimization_packages/mathoptinterface.md",
         "Metaheuristics.jl" => "optimization_packages/metaheuristics.md",

diff --git a/docs/src/API/ad.md b/docs/src/API/ad.md
@@ -13,15 +13,4 @@ The choices for the auto-AD fill-ins with quick descriptions are:
 
 ## Automatic Differentiation Choice API
 
-The following sections describe the Auto-AD choices in detail. These types are defined in the [ADTypes.jl](https://github.com/SciML/ADTypes.jl) package.
-
-```@docs
-ADTypes.AutoForwardDiff
-ADTypes.AutoFiniteDiff
-ADTypes.AutoReverseDiff
-ADTypes.AutoZygote
-ADTypes.AutoTracker
-ADTypes.AutoSymbolics
-ADTypes.AutoEnzyme
-ADTypes.AutoMooncake
-```
+The Auto-AD choices are defined and documented in [ADTypes.jl](https://github.com/SciML/ADTypes.jl). Optimization.jl accepts these choices when constructing optimization functions, but does not own their API.
diff --git a/docs/src/API/optimization_problem.md b/docs/src/API/optimization_problem.md
@@ -2,4 +2,7 @@
 
 ```@docs
 SciMLBase.OptimizationProblem
+OptimizationBase.ObjSense
+OptimizationBase.MinSense
+OptimizationBase.MaxSense
 ```
diff --git a/docs/src/API/solve.md b/docs/src/API/solve.md
@@ -1,5 +1,20 @@
 # Common Solver Options (Solve Keyword Arguments)
 
 ```@docs
-solve(::OptimizationProblem,::Any)
+OptimizationBase.solve(::SciMLBase.OptimizationProblem,::Any)
+OptimizationBase.OptimizationCache
+OptimizationBase.DEFAULT_CALLBACK
+OptimizationBase.DEFAULT_DATA
+OptimizationBase.IncompatibleOptimizerError
+OptimizationBase.OptimizerMissingError
+OptimizationBase.OptimizationVerbosity
+OptimizationBase.allowsbounds
+OptimizationBase.requiresbounds
+OptimizationBase.allowsconstraints
+OptimizationBase.requiresconstraints
+OptimizationBase.allowscallback
+OptimizationBase.requiresgradient
+OptimizationBase.requireshessian
+OptimizationBase.requiresconsjac
+OptimizationBase.requiresconshess
 ```
diff --git a/docs/src/index.md b/docs/src/index.md
@@ -39,7 +39,7 @@ the top level package does not add any extra behavior.
 ## Contributing
 
   - Please refer to the
-    [SciML ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://github.com/SciML/ColPrac/blob/master/README.md)
+    [SciML ColPrac: Contributor's Guide on Collaborative Practices for Community Packages](https://sciml.github.io/ColPrac/)
     for guidance on PRs, issues, and other matters relating to contributing to SciML.
 
   - See the [SciML Style Guide](https://github.com/SciML/SciMLStyle) for common coding practices and other style decisions.

diff --git a/docs/src/optimization_packages/auglag.md b/docs/src/optimization_packages/auglag.md
@@ -0,0 +1,35 @@
+# AugLag.jl
+
+`OptimizationAuglag.jl` provides an augmented Lagrangian wrapper for constrained
+Optimization.jl problems. It repeatedly solves augmented subproblems with a user
+selected inner optimizer.
+
+## Installation: OptimizationAuglag.jl
+
+```julia
+import Pkg
+Pkg.add("OptimizationAuglag")
+```
+
+## Methods
+
+```@docs
+OptimizationAuglag.AugLag
+```
+
+## Example
+
+```julia
+using Optimization, OptimizationAuglag, OptimizationOptimJL, ADTypes
+
+rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
+cons(res, x, p) = (res .= [x[1]^2 + x[2]^2])
+
+optf = OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff(); cons)
+prob = OptimizationProblem(
+    optf, zeros(2), [1.0, 100.0];
+    lcons = [1.0], ucons = [1.0],
+)
+
+sol = solve(prob, AugLag(inner = BFGS()); maxiters = 100)
+```
diff --git a/docs/src/optimization_packages/blackboxoptim.md b/docs/src/optimization_packages/blackboxoptim.md
@@ -53,6 +53,25 @@ The recommended optimizer is `BBO_adaptive_de_rand_1_bin_radiuslimited()`
 
 The currently available algorithms are listed [here](https://github.com/robertfeldt/BlackBoxOptim.jl#state-of-the-library)
 
+```@docs
+OptimizationBBO.BBO_separable_nes
+OptimizationBBO.BBO_xnes
+OptimizationBBO.BBO_dxnes
+OptimizationBBO.BBO_adaptive_de_rand_1_bin
+OptimizationBBO.BBO_adaptive_de_rand_1_bin_radiuslimited
+OptimizationBBO.BBO_de_rand_1_bin
+OptimizationBBO.BBO_de_rand_1_bin_radiuslimited
+OptimizationBBO.BBO_de_rand_2_bin
+OptimizationBBO.BBO_de_rand_2_bin_radiuslimited
+OptimizationBBO.BBO_generating_set_search
+OptimizationBBO.BBO_probabilistic_descent
+OptimizationBBO.BBO_resampling_memetic_search
+OptimizationBBO.BBO_resampling_inheritance_memetic_search
+OptimizationBBO.BBO_simultaneous_perturbation_stochastic_approximation
+OptimizationBBO.BBO_random_search
+OptimizationBBO.BBO_borg_moea
+```
+
 ## Example
 
 The Rosenbrock function can be optimized using the `BBO_adaptive_de_rand_1_bin_radiuslimited()` as follows:

diff --git a/docs/src/optimization_packages/cmaevolutionstrategy.md b/docs/src/optimization_packages/cmaevolutionstrategy.md
@@ -20,6 +20,10 @@ Pkg.add("OptimizationCMAEvolutionStrategy");
 The method in [`CMAEvolutionStrategy`](https://github.com/jbrea/CMAEvolutionStrategy.jl) is performing global optimization on problems without
 constraint equations. However, lower and upper constraints set by `lb` and `ub` in the `OptimizationProblem` are required.
 
+```@docs
+OptimizationCMAEvolutionStrategy.CMAEvolutionStrategyOpt
+```
+
 ## Example
 
 The Rosenbrock function can be optimized using the `CMAEvolutionStrategyOpt()` as follows:

diff --git a/docs/src/optimization_packages/gcmaes.md b/docs/src/optimization_packages/gcmaes.md
@@ -20,6 +20,10 @@ The GCMAES algorithm is called by `GCMAESOpt()` and the initial search variance
 The method in [`GCMAES`](https://github.com/AStupidBear/GCMAES.jl) is performing global optimization on problems without
 constraint equations. However, lower and upper constraints set by `lb` and `ub` in the `OptimizationProblem` are required.
 
+```@docs
+OptimizationGCMAES.GCMAESOpt
+```
+
 ## Example
 
 The Rosenbrock function can be optimized using the `GCMAESOpt()` without utilizing the gradient information as follows:

diff --git a/docs/src/optimization_packages/ipopt.md b/docs/src/optimization_packages/ipopt.md
@@ -30,6 +30,10 @@ OptimizationIpopt.jl provides the `IpoptOptimizer` algorithm, which wraps the Ip
 - Problems with nonlinear constraints
 - Problems requiring high accuracy solutions
 
+```@docs
+OptimizationIpopt.IpoptOptimizer
+```
+
 ### Algorithm Requirements
 
 `IpoptOptimizer` requires:

diff --git a/docs/src/optimization_packages/madnlp.md b/docs/src/optimization_packages/madnlp.md
@@ -0,0 +1,30 @@
+# MadNLP.jl
+
+`OptimizationMadNLP.jl` connects Optimization.jl problems to
+[`MadNLP.jl`](https://github.com/MadNLP/MadNLP.jl), a nonlinear programming
+solver for large-scale constrained optimization.
+
+## Installation: OptimizationMadNLP.jl
+
+```julia
+import Pkg
+Pkg.add("OptimizationMadNLP")
+```
+
+## Methods
+
+```@docs
+OptimizationMadNLP.MadNLPOptimizer
+```
+
+## Example
+
+```julia
+using Optimization, OptimizationMadNLP, ADTypes
+
+rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2
+optf = OptimizationFunction(rosenbrock, ADTypes.AutoForwardDiff())
+prob = OptimizationProblem(optf, zeros(2), [1.0, 100.0])
+
+sol = solve(prob, MadNLPOptimizer())
+```
diff --git a/docs/src/optimization_packages/manopt.md b/docs/src/optimization_packages/manopt.md
@@ -27,6 +27,17 @@ The following methods are available for the `OptimizationManopt` package:
   - `ConvexBundleOptimizer`: Corresponds to the [`convex_bundle_method`](https://manoptjl.org/stable/solvers/convex_bundle_method/) method in Manopt.
   - `FrankWolfeOptimizer`: Corresponds to the [`FrankWolfe`](https://manoptjl.org/stable/solvers/FrankWolfe/) method in Manopt.
 
+```@docs
+OptimizationManopt.GradientDescentOptimizer
+OptimizationManopt.NelderMeadOptimizer
+OptimizationManopt.ConjugateGradientDescentOptimizer
+OptimizationManopt.ParticleSwarmOptimizer
+OptimizationManopt.QuasiNewtonOptimizer
+OptimizationManopt.CMAESOptimizer
+OptimizationManopt.ConvexBundleOptimizer
+OptimizationManopt.FrankWolfeOptimizer
+```
+
 The common kwargs `maxiters`, `maxtime` and `abstol` are supported by all the optimizers. Solver specific kwargs from Manopt can be passed to the `solve`
 function or `OptimizationProblem`.
 

diff --git a/docs/src/optimization_packages/nlpmodels.md b/docs/src/optimization_packages/nlpmodels.md
@@ -52,3 +52,8 @@ sol = solve(prob, Ipopt.Optimizer())
 
 Problems represented as `NLPModel`s can be used to create [`OptimizationProblem`](@ref)s and
 [`OptimizationFunction`](@ref).
+
+```@docs
+OptimizationNLPModels.NLPModelsAdaptor
+OptimizationNLPModels.build_nlpmodel_meta
+```
diff --git a/docs/src/optimization_packages/nomad.md b/docs/src/optimization_packages/nomad.md
@@ -26,6 +26,10 @@ constraint equations. However, linear and nonlinear constraints defined in `Opti
 
 NOMAD works both with and without lower and upper box-constraints set by `lb` and `ub` in the `OptimizationProblem`.
 
+```@docs
+OptimizationNOMAD.NOMADOpt
+```
+
 ## Examples
 
 The Rosenbrock function can be optimized using the `NOMADOpt()` with and without box-constraints as follows:

diff --git a/docs/src/optimization_packages/ode.md b/docs/src/optimization_packages/ode.md
@@ -49,6 +49,14 @@ All provided optimizers are **gradient-based local optimizers** that solve optim
 
 You can also define a custom optimizer using the generic `ODEOptimizer(solver; dt=nothing)` constructor by supplying any ODE solver supported by [OrdinaryDiffEq.jl](https://docs.sciml.ai/DiffEqDocs/stable/solvers/ode_solve/).
 
+```@docs
+OptimizationODE.ODEOptimizer
+OptimizationODE.ODEGradientDescent
+OptimizationODE.RKChebyshevDescent
+OptimizationODE.RKAccelerated
+OptimizationODE.HighOrderDescent
+```
+
 ## DAE-based Optimizers
 
 !!! warn
@@ -62,6 +70,11 @@ In addition to ODE-based optimizers, OptimizationODE.jl provides optimizers for
 
 You can also define a custom optimizer using the generic `ODEOptimizer(solver)` or `DAEOptimizer(solver)` constructor by supplying any ODE or DAE solver supported by [OrdinaryDiffEq.jl](https://docs.sciml.ai/DiffEqDocs/stable/solvers/ode_solve/) or [Sundials.jl](https://github.com/SciML/Sundials.jl).
 
+```@docs
+OptimizationODE.DAEOptimizer
+OptimizationODE.DAEMassMatrix
+```
+
 ## Interface Details
 
 All optimizers require gradient information (either via automatic differentiation or manually provided `grad!`). The optimization is performed by integrating the ODE defined by the negative gradient until a steady state is reached.
diff --git a/docs/src/optimization_packages/polyopt.md b/docs/src/optimization_packages/polyopt.md
@@ -17,6 +17,10 @@ Right now we support the following polyalgorithms.
 
 `PolyOpt`: Runs Adam followed by BFGS for an equal number of iterations. This is useful in scientific machine learning use cases, by exploring the loss surface with the stochastic optimizer and converging to the minima faster with BFGS.
 
+```@docs
+OptimizationPolyalgorithms.PolyOpt
+```
+
 ```@example polyopt
 using Optimization, OptimizationPolyalgorithms, ADTypes, ForwardDiff
 rosenbrock(x, p) = (p[1] - x[1])^2 + p[2] * (x[2] - x[1]^2)^2

diff --git a/docs/src/optimization_packages/prima.md b/docs/src/optimization_packages/prima.md
@@ -25,6 +25,14 @@ The five Powell's algorithms of the prima library are provided by the PRIMA.jl p
 
 `COBYLA`: (Constrained Optimization BY Linear Approximations) is for general constrained problems with bound constraints, non-linear constraints, linear equality constraints, and linear inequality constraints.
 
+```@docs
+OptimizationPRIMA.UOBYQA
+OptimizationPRIMA.NEWUOA
+OptimizationPRIMA.BOBYQA
+OptimizationPRIMA.LINCOA
+OptimizationPRIMA.COBYLA
+```
+
 ```@example PRIMA
 using OptimizationBase, OptimizationPRIMA
 

diff --git a/docs/src/optimization_packages/pycma.md b/docs/src/optimization_packages/pycma.md
@@ -15,6 +15,10 @@ Pkg.add("OptimizationPyCMA")
 
 `PyCMAOpt` supports the usual keyword arguments `maxiters`, `maxtime`, `abstol`, `reltol`, `callback` in addition to any PyCMA-specific options (passed verbatim via keyword arguments to `solve`).
 
+```@docs
+OptimizationPyCMA.PyCMAOpt
+```
+
 ## Example
 
 ```@example PyCMA

diff --git a/docs/src/optimization_packages/quaddirect.md b/docs/src/optimization_packages/quaddirect.md
@@ -31,6 +31,10 @@ constraint equations. However, lower and upper constraints set by `lb` and `ub`
 Furthermore, `QuadDirect` requires `splits` which is a list of 3-vectors with initial locations at which to evaluate the function (the values must be in strictly increasing order and lie within the specified bounds) such that
 `solve(problem, QuadDirect(), splits)`.
 
+```@docs
+OptimizationQuadDIRECT.QuadDirect
+```
+
 ## Example
 
 The Rosenbrock function can be optimized using the `QuadDirect()` as follows:

diff --git a/docs/src/optimization_packages/scipy.md b/docs/src/optimization_packages/scipy.md
@@ -55,7 +55,44 @@ Below is a catalogue of the solver families exposed by `OptimizationSciPy.jl` to
 
 ### Root Finding & Non-Linear Least Squares *(experimental)*
 
-Support for `ScipyRoot`, `ScipyRootScalar` and `ScipyLeastSquares` is available behind the scenes and will be documented once the APIs stabilise.
+Support for `ScipyRoot`, `ScipyRootScalar` and `ScipyLeastSquares` is available for experimental root-finding and non-linear least-squares workflows.
+
+```@docs
+OptimizationSciPy.ScipyMinimize
+OptimizationSciPy.ScipyNelderMead
+OptimizationSciPy.ScipyPowell
+OptimizationSciPy.ScipyCG
+OptimizationSciPy.ScipyBFGS
+OptimizationSciPy.ScipyNewtonCG
+OptimizationSciPy.ScipyLBFGSB
+OptimizationSciPy.ScipyTNC
+OptimizationSciPy.ScipyCOBYLA
+OptimizationSciPy.ScipyCOBYQA
+OptimizationSciPy.ScipySLSQP
+OptimizationSciPy.ScipyTrustConstr
+OptimizationSciPy.ScipyDogleg
+OptimizationSciPy.ScipyTrustNCG
+OptimizationSciPy.ScipyTrustKrylov
+OptimizationSciPy.ScipyTrustExact
+OptimizationSciPy.ScipyMinimizeScalar
+OptimizationSciPy.ScipyBrent
+OptimizationSciPy.ScipyBounded
+OptimizationSciPy.ScipyGolden
+OptimizationSciPy.ScipyLeastSquares
+OptimizationSciPy.ScipyLeastSquaresTRF
+OptimizationSciPy.ScipyLeastSquaresDogbox
+OptimizationSciPy.ScipyLeastSquaresLM
+OptimizationSciPy.ScipyRootScalar
+OptimizationSciPy.ScipyRoot
+OptimizationSciPy.ScipyLinprog
+OptimizationSciPy.ScipyMilp
+OptimizationSciPy.ScipyDifferentialEvolution
+OptimizationSciPy.ScipyBasinhopping
+OptimizationSciPy.ScipyDualAnnealing
+OptimizationSciPy.ScipyShgo
+OptimizationSciPy.ScipyDirect
+OptimizationSciPy.ScipyBrute
+```
 
 ## Examples