diff --git a/docs/src/examples/augmented_neural_ode.md b/docs/src/examples/augmented_neural_ode.md
index 29460dd4c..7744319bb 100644
--- a/docs/src/examples/augmented_neural_ode.md
+++ b/docs/src/examples/augmented_neural_ode.md
@@ -78,7 +78,7 @@ cb = function()
 end
 
 model, parameters = construct_model(1, 2, 64, 0)
-opt = ADAM(0.005)
+opt = Adam(0.005)
 
 println("Training Neural ODE")
 
@@ -89,7 +89,7 @@ end
 plt_node = plot_contour(model)
 
 model, parameters = construct_model(1, 2, 64, 1)
-opt = ADAM(5f-3)
+opt = Adam(5f-3)
 
 println()
 println("Training Augmented Neural ODE")
@@ -237,10 +237,10 @@ end
 
 ### Optimizer
 
-We use ADAM as the optimizer with a learning rate of 0.005
+We use Adam as the optimizer with a learning rate of 0.005
 
 ```@example augneuralode
-opt = ADAM(5f-3)
+opt = Adam(5f-3)
 ```
 
 ## Training the Neural ODE
diff --git a/docs/src/examples/collocation.md b/docs/src/examples/collocation.md
index 0f301c6bc..f476aff51 100644
--- a/docs/src/examples/collocation.md
+++ b/docs/src/examples/collocation.md
@@ -55,7 +55,7 @@ adtype = Optimization.AutoZygote()
 optf = Optimization.OptimizationFunction((x,p) -> loss(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, ComponentArray(pinit))
 
-result_neuralode = Optimization.solve(optprob, ADAM(0.05), callback = callback, maxiters = 10000)
+result_neuralode = Optimization.solve(optprob, Adam(0.05), callback = callback, maxiters = 10000)
 
 prob_neuralode = NeuralODE(dudt2, tspan, Tsit5(), saveat = tsteps)
 nn_sol, st = prob_neuralode(u0, result_neuralode.u, st)
@@ -78,7 +78,7 @@ optf = Optimization.OptimizationFunction((x, p) -> loss_neuralode(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, ComponentArray(pinit))
 
 numerical_neuralode = Optimization.solve(optprob,
-                                       ADAM(0.05),
+                                       Adam(0.05),
                                        callback = callback,
                                        maxiters = 300)
 
@@ -153,7 +153,7 @@ adtype = Optimization.AutoZygote()
 optf = Optimization.OptimizationFunction((x,p) -> loss(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, ComponentArray(pinit))
 
-result_neuralode = Optimization.solve(optprob, ADAM(0.05), callback = callback, maxiters = 10000)
+result_neuralode = Optimization.solve(optprob, Adam(0.05), callback = callback, maxiters = 10000)
 
 prob_neuralode = NeuralODE(dudt2, tspan, Tsit5(), saveat = tsteps)
 nn_sol, st = prob_neuralode(u0, result_neuralode.u, st)
@@ -182,7 +182,7 @@ optf = Optimization.OptimizationFunction((x, p) -> loss_neuralode(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, ComponentArray(pinit))
 
 numerical_neuralode = Optimization.solve(optprob,
-                                       ADAM(0.05),
+                                       Adam(0.05),
                                        callback = callback,
                                        maxiters = 300)
 
diff --git a/docs/src/examples/hamiltonian_nn.md b/docs/src/examples/hamiltonian_nn.md
index d49a6a370..aef9cc141 100644
--- a/docs/src/examples/hamiltonian_nn.md
+++ b/docs/src/examples/hamiltonian_nn.md
@@ -31,7 +31,7 @@ hnn = HamiltonianNN(Lux.Chain(Lux.Dense(2, 64, relu), Lux.Dense(64, 1)))
 ps, st = Lux.setup(Random.default_rng(), hnn)
 ps_c = ps |> ComponentArray
 
-opt = ADAM(0.01f0)
+opt = Adam(0.01f0)
 
 function loss_function(ps, data, target)
     pred, st_ = hnn(data, ps, st)
@@ -90,7 +90,7 @@ hnn = HamiltonianNN(Lux.Chain(Lux.Dense(2, 64, relu), Lux.Dense(64, 1)))
 ps, st = Lux.setup(Random.default_rng(), hnn)
 ps_c = ps |> ComponentArray
 
-opt = ADAM(0.01f0)
+opt = Adam(0.01f0)
 
 function loss_function(ps, data, target)
     pred, st_ = hnn(data, ps, st)
diff --git a/docs/src/examples/mnist_conv_neural_ode.md b/docs/src/examples/mnist_conv_neural_ode.md
index 0e72f4ed3..7b8a015c3 100644
--- a/docs/src/examples/mnist_conv_neural_ode.md
+++ b/docs/src/examples/mnist_conv_neural_ode.md
@@ -100,7 +100,7 @@ loss(x, y) = logitcrossentropy(model(x), y)
 # burn in loss
 loss(img, lab)
 
-opt = ADAM(0.05)
+opt = Adam(0.05)
 iter = 0
 
 callback() = begin
@@ -332,10 +332,10 @@ loss(img, lab)
 
 #### Optimizer
 
-`ADAM` is specified here as our optimizer with a **learning rate of 0.05**:
+`Adam` is specified here as our optimizer with a **learning rate of 0.05**:
 
 ```julia
-opt = ADAM(0.05)
+opt = Adam(0.05)
 ```
 
 #### CallBack
diff --git a/docs/src/examples/mnist_neural_ode.md b/docs/src/examples/mnist_neural_ode.md
index eaed0f44b..a51bcb7d0 100644
--- a/docs/src/examples/mnist_neural_ode.md
+++ b/docs/src/examples/mnist_neural_ode.md
@@ -90,7 +90,7 @@ loss(x, y) = logitcrossentropy(model(x), y)
 # burn in loss
 loss(img, lab)
 
-opt = ADAM(0.05)
+opt = Adam(0.05)
 iter = 0
 
 callback() = begin
@@ -316,10 +316,10 @@ loss(img, lab)
 
 #### Optimizer
 
-`ADAM` is specified here as our optimizer with a **learning rate of 0.05**:
+`Adam` is specified here as our optimizer with a **learning rate of 0.05**:
 
 ```julia
-opt = ADAM(0.05)
+opt = Adam(0.05)
 ```
 
 #### CallBack
diff --git a/docs/src/examples/neural_ode.md b/docs/src/examples/neural_ode.md
index 61a6cfc68..87ec356ae 100644
--- a/docs/src/examples/neural_ode.md
+++ b/docs/src/examples/neural_ode.md
@@ -67,7 +67,7 @@ optf = Optimization.OptimizationFunction((x, p) -> loss_neuralode(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, pinit)
 
 result_neuralode = Optimization.solve(optprob,
-                                       ADAM(0.05),
+                                       Adam(0.05),
                                        callback = callback,
                                        maxiters = 300)
 
@@ -169,7 +169,7 @@ callback(pinit, loss_neuralode(pinit)...)
 
 We then train the neural network to learn the ODE.
 
-Here we showcase starting the optimization with `ADAM` to more quickly find a
+Here we showcase starting the optimization with `Adam` to more quickly find a
 minimum, and then honing in on the minimum by using `LBFGS`. By using the two
 together, we can fit the neural ODE in 9 seconds! (Note, the timing
 commented out the plotting). You can easily incorporate the procedure below to
@@ -182,20 +182,20 @@ The `x` and `p` variables in the optimization function are different from
 the original problem, so `x_optimization` == `p_original`.
 
 ```@example neuralode
-# Train using the ADAM optimizer
+# Train using the Adam optimizer
 adtype = Optimization.AutoZygote()
 
 optf = Optimization.OptimizationFunction((x, p) -> loss_neuralode(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, pinit)
 
 result_neuralode = Optimization.solve(optprob,
-                                       ADAM(0.05),
+                                       Adam(0.05),
                                        callback = callback,
                                        maxiters = 300)
 ```
 
 We then complete the training using a different optimizer, starting from where
-`ADAM` stopped. We do `allow_f_increases=false` to make the optimization automatically
+`Adam` stopped. We do `allow_f_increases=false` to make the optimization automatically
 halt when near the minimum.
 
 ```@example neuralode
diff --git a/docs/src/examples/neural_ode_weather_forecast.md b/docs/src/examples/neural_ode_weather_forecast.md
index 1179e6147..e04fface2 100644
--- a/docs/src/examples/neural_ode_weather_forecast.md
+++ b/docs/src/examples/neural_ode_weather_forecast.md
@@ -14,7 +14,7 @@ using Dates
 using Optimization
 using ComponentArrays
 using Lux
-using DiffEqFlux: NeuralODE, ADAMW, swish
+using DiffEqFlux: NeuralODE, AdamW, swish
 using DifferentialEquations
 using CSV
 using DataFrames
@@ -193,7 +193,7 @@ function train(t, y, obs_grid, maxiters, lr, rng, p=nothing, state=nothing; kwar
         if state === nothing state = state_new end
 
         p, state = train_one_round(
-            node, p, state, y, ADAMW(lr), maxiters, rng;
+            node, p, state, y, AdamW(lr), maxiters, rng;
             callback=log_results(ps, losses),
             kwargs...
         )
diff --git a/docs/src/examples/neural_sde.md b/docs/src/examples/neural_sde.md
index e70252c37..11377b558 100644
--- a/docs/src/examples/neural_sde.md
+++ b/docs/src/examples/neural_sde.md
@@ -161,7 +161,7 @@ smaller `n` and then decrease it after it has had some time to adjust towards
 the right mean behavior:
 
 ```@example nsde
-opt = ADAM(0.025)
+opt = Adam(0.025)
 
 # First round of training with n = 10
 adtype = Optimization.AutoZygote()
diff --git a/docs/src/examples/normalizing_flows.md b/docs/src/examples/normalizing_flows.md
index 1502ae0bd..8eeb1c3bd 100644
--- a/docs/src/examples/normalizing_flows.md
+++ b/docs/src/examples/normalizing_flows.md
@@ -38,7 +38,7 @@ optf = Optimization.OptimizationFunction((x, p) -> loss(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
 
 res1 = Optimization.solve(optprob,
-                          ADAM(0.1),
+                          Adam(0.1),
                           maxiters = 100,
                           callback=cb)
 
@@ -107,7 +107,7 @@ In this example, we wish to choose the parameters of the network such that the l
 
 We then train the neural network to learn the distribution of `x`.
 
-Here we showcase starting the optimization with `ADAM` to more quickly find a minimum, and then honing in on the minimum by using `LBFGS`.
+Here we showcase starting the optimization with `Adam` to more quickly find a minimum, and then honing in on the minimum by using `LBFGS`.
 
 ```@example cnf2
 adtype = Optimization.AutoZygote()
@@ -115,12 +115,12 @@ optf = Optimization.OptimizationFunction((x, p) -> loss(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
 
 res1 = Optimization.solve(optprob,
-                          ADAM(0.1),
+                          Adam(0.1),
                           maxiters = 100,
                           callback=cb)
 ```
 
-We then complete the training using a different optimizer, starting from where `ADAM` stopped.
+We then complete the training using a different optimizer, starting from where `Adam` stopped.
 
 ```@example cnf2
 optprob2 = Optimization.OptimizationProblem(optf, res1.u)
diff --git a/docs/src/examples/tensor_layer.md b/docs/src/examples/tensor_layer.md
index c5ff152d8..097eb406a 100644
--- a/docs/src/examples/tensor_layer.md
+++ b/docs/src/examples/tensor_layer.md
@@ -81,16 +81,16 @@ function callback(θ,l)
 end
 ```
 
-and we train the network using two rounds of `ADAM`:
+and we train the network using two rounds of `Adam`:
 
 ```@example tensor
 adtype = Optimization.AutoZygote()
 optf = Optimization.OptimizationFunction((x,p) -> loss_adjoint(x), adtype)
 optprob = Optimization.OptimizationProblem(optf, α)
-res1 = Optimization.solve(optprob, ADAM(0.05), callback = callback, maxiters = 150)
+res1 = Optimization.solve(optprob, Adam(0.05), callback = callback, maxiters = 150)
 
 optprob2 = Optimization.OptimizationProblem(optf, res1.u)
-res2 = Optimization.solve(optprob2, ADAM(0.001), callback = callback,maxiters = 150)
+res2 = Optimization.solve(optprob2, Adam(0.001), callback = callback,maxiters = 150)
 opt = res2.u
 ```
 
diff --git a/test/cnf_test.jl b/test/cnf_test.jl
index 47fe784eb..ef9f569b7 100644
--- a/test/cnf_test.jl
+++ b/test/cnf_test.jl
@@ -33,7 +33,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=false & monte_carlo=true" begin
             regularize = false
@@ -41,7 +41,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=false" begin
             regularize = true
@@ -49,7 +49,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test_broken !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test_broken !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=true" begin
             regularize = true
@@ -57,7 +57,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
     end
     @testset "AutoReverseDiff as adtype" begin
@@ -68,28 +68,28 @@ end
             monte_carlo = false
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=false & monte_carlo=true" begin
             regularize = false
             monte_carlo = true
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=false" begin
             regularize = true
             monte_carlo = false
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test_broken !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test_broken !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=true" begin
             regularize = true
             monte_carlo = true
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
     end
     @testset "AutoTracker as adtype" begin
@@ -100,28 +100,28 @@ end
             monte_carlo = false
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=false & monte_carlo=true" begin
             regularize = false
             monte_carlo = true
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=false" begin
             regularize = true
             monte_carlo = false
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test_broken !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test_broken !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=true" begin
             regularize = true
             monte_carlo = true
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
     end
     @testset "AutoZygote as adtype" begin
@@ -133,7 +133,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=false & monte_carlo=true" begin
             regularize = false
@@ -141,7 +141,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=false" begin
             regularize = true
@@ -149,7 +149,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test_broken !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test_broken !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=true" begin
             regularize = true
@@ -157,7 +157,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
     end
     @testset "AutoFiniteDiff as adtype" begin
@@ -169,7 +169,7 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=false & monte_carlo=true" begin
             regularize = false
@@ -177,21 +177,21 @@ end
 
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=false" begin
             regularize = true
             monte_carlo = false
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test_broken !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test_broken !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
         @testset "regularize=true & monte_carlo=true" begin
             regularize = true
             monte_carlo = true
             optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
             optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-            @test !isnothing(Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=10))
+            @test !isnothing(Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=10))
         end
     end
 end
@@ -217,7 +217,7 @@ end
 
     optf = Optimization.OptimizationFunction((θ,_) -> loss(θ; regularize, monte_carlo), adtype)
     optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-    res = Optimization.solve(optprob, ADAM(0.1); callback= callback, maxiters=10)
+    res = Optimization.solve(optprob, Adam(0.1); callback= callback, maxiters=10)
 
     ffjord_d = FFJORDDistribution(FFJORD(nn, tspan, Tsit5(); p=res.u); regularize, monte_carlo)
 
@@ -246,7 +246,7 @@ end
     adtype = Optimization.AutoZygote()
     optf = Optimization.OptimizationFunction((θ,_) -> loss(θ), adtype)
     optprob = Optimization.OptimizationProblem(optf, ffjord_mdl.p)
-    res = Optimization.solve(optprob, ADAM(0.1); callback= callback, maxiters=10)
+    res = Optimization.solve(optprob, Adam(0.1); callback= callback, maxiters=10)
 
     actual_pdf = pdf.(data_dist, test_data)
     learned_pdf = exp.(ffjord_mdl(test_data, res.u; regularize, monte_carlo)[1])
@@ -276,7 +276,7 @@ end
     adtype = Optimization.AutoZygote()
     optf = Optimization.OptimizationFunction((θ,_) -> loss(θ), adtype)
     optprob = Optimization.OptimizationProblem(optf, 0.01f0 * ffjord_mdl.p)
-    res = Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=300)
+    res = Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=300)
 
     actual_pdf = pdf.(data_dist, test_data)
     learned_pdf = exp.(ffjord_mdl(test_data, res.u; regularize, monte_carlo)[1])
@@ -307,7 +307,7 @@ end
     adtype = Optimization.AutoZygote()
     optf = Optimization.OptimizationFunction((θ,_) -> loss(θ), adtype)
     optprob = Optimization.OptimizationProblem(optf, 0.01f0 * ffjord_mdl.p)
-    res = Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=300)
+    res = Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=300)
 
     actual_pdf = pdf(data_dist, test_data)
     learned_pdf = exp.(ffjord_mdl(test_data, res.u; regularize, monte_carlo)[1])
@@ -338,7 +338,7 @@ end
     adtype = Optimization.AutoZygote()
     optf = Optimization.OptimizationFunction((θ,_) -> loss(θ), adtype)
     optprob = Optimization.OptimizationProblem(optf, 0.01f0 * ffjord_mdl.p)
-    res = Optimization.solve(optprob, ADAM(0.1); callback = callback, maxiters=300)
+    res = Optimization.solve(optprob, Adam(0.1); callback = callback, maxiters=300)
 
     actual_pdf = pdf(data_dist, test_data)
     learned_pdf = exp.(ffjord_mdl(test_data, res.u; regularize, monte_carlo)[1])
diff --git a/test/hamiltonian_nn.jl b/test/hamiltonian_nn.jl
index 0164efb4f..dc4d86104 100644
--- a/test/hamiltonian_nn.jl
+++ b/test/hamiltonian_nn.jl
@@ -34,7 +34,7 @@ hnn = HamiltonianNN(Lux.Chain(Lux.Dense(2, 16, relu), Lux.Dense(16, 1)))
 ps, st = Lux.setup(Random.default_rng(), hnn)
 ps = ps |> ComponentArray
 
-opt = ADAM(0.01)
+opt = Adam(0.01)
 st_opt = Optimisers.setup(opt, ps)
 loss(data, target, ps) = mean(abs2, first(hnn(data, ps, st)) .- target)
 
diff --git a/test/mnist_conv_gpu.jl b/test/mnist_conv_gpu.jl
index 59fa31715..dc16f76ea 100644
--- a/test/mnist_conv_gpu.jl
+++ b/test/mnist_conv_gpu.jl
@@ -92,7 +92,7 @@ loss(x, y) = logitcrossentropy(model(x), y)
 # burn in loss
 loss(img, lab)
 
-opt = ADAM(0.05)
+opt = Adam(0.05)
 iter = 0
 
 cb() = begin
diff --git a/test/mnist_gpu.jl b/test/mnist_gpu.jl
index 7febe6df7..78639ee07 100644
--- a/test/mnist_gpu.jl
+++ b/test/mnist_gpu.jl
@@ -90,7 +90,7 @@ end
 #burn in loss
 loss_function(ps, x_train[1], y_train[1])
 
-opt = ADAM(0.05)
+opt = Adam(0.05)
 iter = 0
 
 opt_func = OptimizationFunction((ps, _, x, y) -> loss_function(ps, x, y),
diff --git a/test/multiple_shoot.jl b/test/multiple_shoot.jl
index 007ddb3a9..1ccbd2f99 100644
--- a/test/multiple_shoot.jl
+++ b/test/multiple_shoot.jl
@@ -52,7 +52,7 @@ end
 adtype = Optimization.AutoZygote()
 optf = Optimization.OptimizationFunction((p,_)->loss_single_shooting(p), adtype)
 optprob = Optimization.OptimizationProblem(optf, p_init)
-res_single_shooting = Optimization.solve(optprob, ADAM(0.05),
+res_single_shooting = Optimization.solve(optprob, Adam(0.05),
 										  maxiters = 300)
 
 loss_ss, _ = loss_single_shooting(res_single_shooting.minimizer)
@@ -71,7 +71,7 @@ end
 adtype = Optimization.AutoZygote()
 optf = Optimization.OptimizationFunction((p,_)->loss_multiple_shooting(p), adtype)
 optprob = Optimization.OptimizationProblem(optf, p_init)
-res_ms = Optimization.solve(optprob, ADAM(0.05), maxiters = 300)
+res_ms = Optimization.solve(optprob, Adam(0.05), maxiters = 300)
 
 # Calculate single shooting loss with parameter from multiple_shoot training
 loss_ms, _ = loss_single_shooting(res_ms.minimizer)
@@ -95,7 +95,7 @@ end
 adtype = Optimization.AutoZygote()
 optf = Optimization.OptimizationFunction((p,_)->loss_multiple_shooting_abs2(p), adtype)
 optprob = Optimization.OptimizationProblem(optf, p_init)
-res_ms_abs2 = Optimization.solve(optprob, ADAM(0.05), maxiters = 300)
+res_ms_abs2 = Optimization.solve(optprob, Adam(0.05), maxiters = 300)
 
 loss_ms_abs2, _ = loss_single_shooting(res_ms_abs2.minimizer)
 println("Multiple shooting loss with abs2: $(loss_ms_abs2)")
@@ -112,7 +112,7 @@ end
 adtype = Optimization.AutoZygote()
 optf = Optimization.OptimizationFunction((p,_)->loss_multiple_shooting_fd(p), adtype)
 optprob = Optimization.OptimizationProblem(optf, p_init)
-res_ms_fd = Optimization.solve(optprob, ADAM(0.05), maxiters = 300)
+res_ms_fd = Optimization.solve(optprob, Adam(0.05), maxiters = 300)
 
 # Calculate single shooting loss with parameter from multiple_shoot training
 loss_ms_fd, _ = loss_single_shooting(res_ms_fd.minimizer)
@@ -156,7 +156,7 @@ adtype = Optimization.AutoZygote()
 optf = Optimization.OptimizationFunction((p,_)->loss_multiple_shooting_ens(p), adtype)
 optprob = Optimization.OptimizationProblem(optf, p_init)
 res_ms_ensembles = Optimization.solve(optprob,
-                                ADAM(0.05), maxiters = 300)
+                                Adam(0.05), maxiters = 300)
 
 loss_ms_ensembles, _ = loss_single_shooting(res_ms_ensembles.minimizer)
 
diff --git a/test/neural_gde.jl b/test/neural_gde.jl
index 7fe60ab38..5cab7dac4 100644
--- a/test/neural_gde.jl
+++ b/test/neural_gde.jl
@@ -22,7 +22,7 @@ model = Flux.Chain(
 )
 
 ps = Flux.params(model)
-opt = ADAM(0.1)
+opt = Adam(0.1)
 
 initial_loss = Flux.Losses.logitcrossentropy(model(features), target)
 
diff --git a/test/second_order_ode.jl b/test/second_order_ode.jl
index 038d92efb..680f2a531 100644
--- a/test/second_order_ode.jl
+++ b/test/second_order_ode.jl
@@ -24,7 +24,7 @@ function loss_n_ode(p)
 end
 
 data = Iterators.repeated((), 1000)
-opt = ADAM(0.01)
+opt = Adam(0.01)
 
 l1 = loss_n_ode(p)
 
@@ -51,7 +51,7 @@ function loss_n_ode(p)
 end
 
 data = Iterators.repeated((), 1000)
-opt = ADAM(0.01)
+opt = Adam(0.01)
 
 loss_n_ode(p)
 
@@ -77,7 +77,7 @@ function loss_n_ode(p)
 end
 
 data = Iterators.repeated((), 1000)
-opt = ADAM(0.01)
+opt = Adam(0.01)
 
 loss_n_ode(p)
 
diff --git a/test/spline_layer_test.jl b/test/spline_layer_test.jl
index 44f84b8c7..f9330bf76 100644
--- a/test/spline_layer_test.jl
+++ b/test/spline_layer_test.jl
@@ -18,10 +18,10 @@ function run_test(f, layer, atol)
 
     optfunc = Optimization.OptimizationFunction((x, p) -> loss_function(x), Optimization.AutoZygote())
     optprob = Optimization.OptimizationProblem(optfunc, layer.saved_points)
-    res = Optimization.solve(optprob, ADAM(0.1), callback=callback, maxiters = 100)
+    res = Optimization.solve(optprob, Adam(0.1), callback=callback, maxiters = 100)
 
     optprob = Optimization.OptimizationProblem(optfunc, res.minimizer)
-    res = Optimization.solve(optprob, ADAM(0.1), callback=callback, maxiters = 100)
+    res = Optimization.solve(optprob, Adam(0.1), callback=callback, maxiters = 100)
     opt = res.minimizer
 
     data_validate_vals = rand(100)
diff --git a/test/stiff_nested_ad.jl b/test/stiff_nested_ad.jl
index 3786b45ee..8e9e617ae 100644
--- a/test/stiff_nested_ad.jl
+++ b/test/stiff_nested_ad.jl
@@ -23,7 +23,7 @@ end
 loss_n_ode() = sum(abs2,ode_data .- predict_n_ode())
 
 data = Iterators.repeated((), 10)
-opt = ADAM(0.1)
+opt = Adam(0.1)
 cb = function () #callback function to observe training
   display(loss_n_ode())
 end
diff --git a/test/tensor_product_test.jl b/test/tensor_product_test.jl
index 7342045f8..79917d42d 100644
--- a/test/tensor_product_test.jl
+++ b/test/tensor_product_test.jl
@@ -19,9 +19,9 @@ function run_test(f, layer, atol)
 
     optfunc = Optimization.OptimizationFunction((x, p) -> loss_function(x), Optimization.AutoZygote())
     optprob = Optimization.OptimizationProblem(optfunc, layer.p)
-    res = Optimization.solve(optprob, ADAM(0.1), callback=cb, maxiters = 100)
+    res = Optimization.solve(optprob, Adam(0.1), callback=cb, maxiters = 100)
     optprob = Optimization.OptimizationProblem(optfunc, res.minimizer)
-    res = Optimization.solve(optprob, ADAM(0.01), callback=cb, maxiters = 100)
+    res = Optimization.solve(optprob, Adam(0.01), callback=cb, maxiters = 100)
     optprob = Optimization.OptimizationProblem(optfunc, res.minimizer)
     res = Optimization.solve(optprob, BFGS(), callback=cb, maxiters = 200)
     opt = res.minimizer